diff --git a/.github/workflows/macos-app.yml b/.github/workflows/macos-app.yml
index 9feb715..0036cb2 100644
--- a/.github/workflows/macos-app.yml
+++ b/.github/workflows/macos-app.yml
@@ -8,12 +8,14 @@ on:
     paths:
       - "macos/**"
       - "devdash/**"
+      - "tests/**"
       - "CHANGELOG.md"
       - ".github/workflows/macos-app.yml"
   pull_request:
     paths:
       - "macos/**"
       - "devdash/**"
+      - "tests/**"
       - "CHANGELOG.md"
       - ".github/workflows/macos-app.yml"
   workflow_dispatch:
@@ -36,6 +38,11 @@ jobs:
         with:
           fetch-depth: 0
 
+      - name: Python tests
+        run: |
+          python3 -m pip install --quiet psutil pytest
+          python3 -m pytest -q tests
+
       - name: Check version and release notes
         id: check
         run: |
diff --git a/CHANGELOG.md b/CHANGELOG.md
index fe76314..fadd9d5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,43 @@
 # Changelog
 
+## 0.7.0
+
+### Added
+- **Run dev servers**: a project's menu in Running has **Run dev** (the script you ran last, else `dev`, `start`, `serve` or `preview`) and a **Run** submenu with every package.json script, the dev scripts of workspace packages and the entries of `Procfile.dev` or `Procfile`. The package manager comes from the lockfile or the `packageManager` field.
+- **Ready to run**: recent Claude Code projects with nothing running are listed at the bottom of Running, each with a play button.
+- Servers devdash started get a chip with the script name, and Restart, Stop and Logs buttons. Stop ends the script's whole process group, so the servers `npm run dev` or turbo started stop with it.
+- **Logs**: output goes to `~/.local/share/devdash/runs/<project>/<script>.log` (kept under 5 MB) and opens in the logs window, with filter, follow, Restart and Stop.
+- **Restart when it crashes**, per server, off by default: restarts after 2 seconds, at most 3 times in 5 minutes.
+- A crash shows up in Needs you with the exit code and a notification. Runs without a port (workers, watchers) and runs that ended keep a row in their project.
+- When a port the script used last time is held by another process, the run doesn't start; Needs you names the process and offers **Stop and run**.
+- Servers keep running when the menu bar app quits, like servers started in a terminal, and devdash picks them up again on the next launch.
+- `devdash --serve` sends `runs`, `runnable` (when it changes) and each server's `run_id`, and has `run_script`, `stop_run`, `restart_run`, `clear_run` and `restart_on_crash` commands.
+
+### Changed
+- Stop All in a project stops the runs devdash started as a whole.
+- Notifications for servers devdash started are about crashes only, not every start and stop.
+
+## 0.6.0
+
+### Added
+- **Worktrees**: a page with every linked git worktree of the repositories devdash knows about (projects with something running and the Claude Code projects of every account), with the branch, who created it, when it was last touched, its size, and whether it's running, has changes, is merged, or is stale. Open it from the footer or from **Worktrees** in a project's menu.
+- Remove a worktree from its row: `git worktree remove`, `git worktree prune`, and `git branch -d` for merged branches. Worktrees with changes, with a server or Claude session running in them, and the main checkout can't be removed.
+- Branches count as merged when they are merged into the default branch or their remote branch is gone, so squash-merged pull requests are caught too.
+- Needs you lists merged worktrees nothing has touched for a day.
+- Projects that are linked worktrees get a stacked icon on their branch chip in Running.
+- `devdash --serve` sends a `worktrees` list when it changes (scanned once a minute) and has `refresh_worktrees`, `worktree_size` and `remove_worktree` commands.
+
+## 0.5.0
+
+### Added
+- **Server URLs and QR codes**: the QR button on a dev server, or Show QR Code in its menu, opens a page with the server's network URL as a QR code, so a phone on the same Wi-Fi opens it in one scan. It also lists the localhost and network URLs with copy and open buttons, and a port picker for servers with several ports.
+- Servers that listen on localhost only say "Only this Mac can open it" and show how to fix that for their runtime, such as `--host` for Vite or `--host 0.0.0.0` for uvicorn.
+- Server menus have Copy Network URL and Show QR Code. Option-click a port chip to copy its URL.
+- `devdash --serve` reports each server's `urls` (port, localhost URL, network URL and whether other devices can reach it), an `expose_hint`, and the Mac's `lan_ip`.
+
+### Changed
+- Port chips, Open and Copy URL use https for servers that speak TLS, such as Vite with `--https`.
+
 ## 0.4.0
 
 ### Added
diff --git a/README.md b/README.md
index 6550a1c..ed6864c 100644
--- a/README.md
+++ b/README.md
@@ -11,6 +11,9 @@ See and manage your dev servers, Docker containers and Claude Code sessions from
 ## Features
 
 - **Dev servers**: every process listening on a port, in any language (Node, Bun, Deno, Python, Ruby, Go, Rust and more), with its memory, CPU and the project it belongs to. Local databases such as Homebrew Postgres show up as services.
+- **Open on your phone**: each dev server's network URL and a QR code, so a phone on the same Wi-Fi opens it in one scan. Servers only this Mac can reach say so, with the flag that fixes it. See [Server URLs and QR codes](#server-urls-and-qr-codes).
+- **Run dev servers**: start any package.json script or Procfile entry from the menu bar, then restart, stop and read its logs there. Optional restart on crash, and a warning when another process holds the port. See [Running dev servers](#running-dev-servers).
+- **Git worktrees**: every linked worktree of the repositories you work in, such as the ones Claude Code creates, with uncommitted changes, merged branches and what runs in them. Remove the merged ones in one click. See [Worktrees](#worktrees).
 - **Docker**: containers grouped by Compose stack, with status, health and ports.
 - **Cleanup**: flags idle, orphaned and zombie processes and long-running containers, and lets you remove them in one click.
 - **Disk tree**: a treemap of your home folder that shows what takes up space and suggests what you can safely reclaim.
@@ -77,8 +80,11 @@ What you can do:
 
 - **Needs you**: one list at the top for anything that wants your attention: cleanup suggestions, low disk space, disk space worth a look, and plan limits over 80%. Dismiss an item and it stays hidden until it changes. The list disappears when there is nothing to show.
 - **Running**: dev servers, Docker containers and Claude sessions, grouped by project (the git repository they run in). Each project header shows the branch and has a menu to open the project in your editor, Finder or Terminal, start a Claude session there, or stop everything in it. Services, servers outside any project and Node processes without a port are grouped at the bottom. Choose **Type** next to the filter to group by dev servers, Compose stacks, Claude sessions, services and background processes instead.
-  - Click a port chip to open `localhost:<port>`. Hover a row to open it in your editor or kill it (click twice to confirm). Right-click any row for all its actions.
+  - Click a port chip to open `localhost:<port>` (https when the server speaks it), or Option-click to copy the URL. Hover a row to open it in your editor or kill it (click twice to confirm). Right-click any row for all its actions.
   - Click a server for process details: command, children, network connections, open files and environment. Click a container to stream its logs in a separate window, with filtering, follow mode and copy.
+- **Run dev servers**: **Run dev** and a **Run** submenu in every project's menu, and recent projects under **Ready to run**. See [Running dev servers](#running-dev-servers).
+- **Worktrees**: the footer button lists every linked git worktree, and Needs you shows merged ones nothing has touched for a day. See [Worktrees](#worktrees).
+- **Server URLs**: right-click a server for Copy URL, Copy Network URL and Show QR Code, or hover it and click the QR button. See [Server URLs and QR codes](#server-urls-and-qr-codes).
 - **System**: CPU, memory, disk, swap and network, the Disk tree summary, and the top processes sorted by memory or CPU. The header shows CPU and memory on every tab; click it to open this tab.
 - **Claude**:
   - plan limits and API-equivalent cost;
@@ -88,9 +94,61 @@ What you can do:
 - **Footer**: Disk tree, dependency graph and activity heatmap. The `...` menu has JSON export, the terminal UI, What's new, Check for updates and Quit.
 - **Keep awake**: the cup in the header. While it's on, the Mac doesn't sleep, and after 50 seconds without input devdash moves the cursor one point and back, too fast to see, so Teams and Slack keep you active. Moving the cursor needs Accessibility access, which macOS asks for the first time you turn it on; without it only the sleep prevention works. It stays on across restarts. More in [Mouse jiggler for Mac](https://bavrk.com/articles/mouse-jiggler-for-mac).
 - **Keyboard**: Cmd+1 to Cmd+3 switch tabs, Cmd+F filters, Esc clears the filter.
-- **Notifications**: a macOS notification when a dev server starts or exits, a container stops, or a watched port comes up.
+- **Notifications**: a macOS notification when a dev server starts or exits, a container stops, a watched port comes up, or a server devdash started crashes.
 - **Settings**: launch at login, editor (VS Code or Cursor), whether the menu bar shows the count and usage percentage, notifications, and a custom `devdash` path.
 
+### Server URLs and QR codes
+
+| Open on your phone | Localhost only |
+|---|---|
+| ![QR code for a dev server](screenshots/app/qrcode.png) | ![A server only this Mac can reach](screenshots/app/qrcode-localhost.png) |
+
+To try a dev server on your phone, hover it in Running and click the QR button, then scan the code with the phone's camera. The phone has to be on the same Wi-Fi as the Mac. The page also lists the server's localhost and network URLs with copy and open buttons, and a port picker when the server listens on more than one.
+
+A phone can only reach a server that listens on all interfaces (`0.0.0.0` or `::`). Vite, Astro, uvicorn, Rails and many other dev servers listen on `localhost` by default, so the page says "Only this Mac can open it" and shows the flag for that server, such as `--host` for Vite or `--host 0.0.0.0` for uvicorn. If the code still doesn't open, check that the macOS firewall allows incoming connections for the server's runtime (System Settings > Network > Firewall).
+
+The network address is the Mac's private IPv4 address on Wi-Fi or Ethernet. VPN tunnels are skipped. More in [How to access localhost from your phone](https://bavrk.com/articles/access-localhost-from-phone).
+
+### Running dev servers
+
+| Ready to run | Port in use |
+|---|---|
+| ![Recent projects with a play button](screenshots/app/ready.png) | ![Needs you offering to stop the process that holds the port](screenshots/app/port-conflict.png) |
+
+![The logs window of a server devdash started](screenshots/app/logs.png)
+
+Every project in Running has **Run dev** in its menu (the `...` on its header, or right-click), plus a **Run** submenu with everything it can run:
+
+- the scripts in its `package.json`, run with the package manager its lockfile or `packageManager` field names (npm, pnpm, yarn or bun);
+- the `dev`, `start`, `serve` and `preview` scripts of its workspace packages (`workspaces` in package.json, or `pnpm-workspace.yaml`);
+- the entries of `Procfile.dev`, or `Procfile` when there is no `Procfile.dev`.
+
+**Run dev** starts the script you ran last in that project, or else the first of `dev`, `start`, `serve` and `preview`. Recent Claude Code projects with nothing running are listed under **Ready to run** at the bottom of Running, with a play button.
+
+Scripts run in your login shell's environment, so nvm, fnm, mise and asdf pick the same Node or Python as in a terminal. A server devdash started gets a chip with the script name and three buttons: **Restart**, **Stop** and **Logs**. Stop sends SIGTERM to the script's whole process group and SIGKILL after 5 seconds, so the servers `npm run dev` or turbo started stop too. The output goes to `~/.local/share/devdash/runs/<project>/<script>.log`, which devdash keeps under 5 MB, and the logs window follows it with a filter.
+
+Right-click a server devdash started and choose **Restart When It Crashes** to have devdash bring it back 2 seconds after it exits with an error, at most 3 times in 5 minutes. A crash also shows up in Needs you with its exit code and a link to the logs. Runs that have no port yet, such as workers, and runs that ended stay in their project with their status until you remove them.
+
+Before a run starts, devdash checks the ports it used last time (and any `--port`, `-p` or `PORT=` in the script). When another process holds one, the run doesn't start and Needs you says which process it is, with **Stop and run**. devdash never stops a process you didn't ask it to. More in [Kill the process on a port on Mac](https://bavrk.com/articles/kill-process-on-port).
+
+Servers keep running when you quit the menu bar app, like servers started in a terminal. devdash picks them up again on the next launch, but can only restart a crashed server while it's running.
+
+### Worktrees
+
+![Worktrees](screenshots/app/worktrees.png)
+
+Coding agents create a git worktree per task and rarely clean up after themselves. The Worktrees page (in the footer, or **Worktrees** in a project's menu) lists every linked worktree of the repositories devdash knows about: projects that have something running, and your Claude Code projects in every account. Repositories without linked worktrees are left out.
+
+Each worktree shows its branch, which tool created it (Claude Code worktrees get the Claude mark), when it was last touched, its size, and a status:
+
+- **Running**: a dev server or Claude session is running in it.
+- **Changes**: it has uncommitted or untracked files.
+- **Merged**: its branch is merged into the default branch (`origin/main` when there is a remote), or its remote branch is gone, which is what a squash merge on GitHub leaves behind.
+- **Stale**: untouched for a week.
+- **Active**: everything else.
+
+Remove a worktree from its row or right-click menu. devdash runs `git worktree remove`, then `git worktree prune`, and for merged branches `git branch -d`, which keeps a branch git doesn't consider merged (squash merges) and says so. It never forces anything: worktrees with changes, with something running in them, locked ones and the main checkout can't be removed from devdash. Merged worktrees nothing has touched for a day also appear under Needs you. More in [git worktree remove: clean up worktrees without --force](https://bavrk.com/articles/git-worktree-remove).
+
 ### Disk tree
 
 ![Disk tree](screenshots/app/disk-tree.png)
@@ -320,6 +378,11 @@ devdash/
   processes.py     # process, Docker, system and Claude Code data collection
   claude_usage.py  # plan limits and API-equivalent cost from transcripts
   claude_profiles.py # Claude Code profiles from ~/.config/claude-profiles
+  servers.py       # dev servers in any language and the project each belongs to
+  network.py       # LAN address and the network URL of each server
+  worktrees.py     # git worktrees across repositories, and removing them safely
+  runnable.py      # package.json scripts and Procfile entries a project can run
+  supervisor.py    # dev servers devdash starts: restart, stop, logs, restart on crash
   bridge.py        # JSON-lines bridge for the menu bar app (--serve)
   demo.py          # synthetic data for --demo and screenshots
   cli.py           # command-line entry point
diff --git a/devdash/__init__.py b/devdash/__init__.py
index 6a9beea..49e0fc1 100644
--- a/devdash/__init__.py
+++ b/devdash/__init__.py
@@ -1 +1 @@
-__version__ = "0.4.0"
+__version__ = "0.7.0"
diff --git a/devdash/bridge.py b/devdash/bridge.py
index 8202bd8..d6245a0 100644
--- a/devdash/bridge.py
+++ b/devdash/bridge.py
@@ -39,10 +39,15 @@
     kill_process,
     stop_docker_container,
 )
+from devdash.network import lan_ip
 from devdash.servers import get_servers, project_infos, resolve_project
+from devdash.supervisor import PortConflict, Supervisor, shell_env
+from devdash import runnable, worktrees
 
 CLAUDE_REFRESH_EVERY = 5  # ticks
 USAGE_REFRESH_SECONDS = 30.0
+WORKTREES_REFRESH_SECONDS = 60.0
+RECENT_PROJECTS = 10  # per Claude profile, offered under "Ready to run"
 
 
 def _asdict(obj):
@@ -80,11 +85,27 @@ def __init__(self, config: Config) -> None:
         self._all_procs = []
         self._stats = None
         self._claude_roots: set[str] = set()
+        self._claude_cwds: list[str] = []
         self._usage_enabled = self._has_claude
         self._trackers: dict[str, UsageTracker] = {}
         self._usage_payload: dict | None = None
         self._usage_version = 0
         self._usage_sent = 0
+        self._busy_cwds: list[str] = []  # where servers and Claude sessions run, for remove_worktree
+        self._snapshot_roots: set[str] = set()
+        self._worktrees_wake = threading.Event()
+        self._worktrees_payload: list | None = None
+        self._worktrees_version = 0
+        self._worktrees_sent = 0
+        self._supervisor = self._create_supervisor()
+        self._servers: list[dict] = []  # last snapshot's servers, to check ports before a run
+        self._recent_roots: set[str] = set()
+        self._runnable_payload: list | None = None
+        self._runnable_version = 0
+        self._runnable_sent = 0
+
+    def _create_supervisor(self) -> Supervisor | None:
+        return Supervisor(on_change=self._wake.set)
 
     # -- output --------------------------------------------------------------
 
@@ -112,6 +133,9 @@ def run(self) -> None:
         threading.Thread(target=self._read_commands, daemon=True).start()
         if self._usage_enabled:
             threading.Thread(target=self._usage_loop, daemon=True).start()
+        threading.Thread(target=self._worktrees_loop, daemon=True).start()
+        if self._supervisor is not None:
+            threading.Thread(target=shell_env, daemon=True).start()  # takes a second or two, so read it early
         time.sleep(0.5)
         while not self._stop.is_set():
             try:
@@ -161,16 +185,30 @@ def _snapshot(self) -> dict:
         docker_ports = {port for c in docker for port in _parse_host_ports_from_string(c.ports)}
         servers = get_servers({p.pid for p in node_procs}, docker_ports)
 
+        server_dicts = [_asdict(s) for s in servers]
+        if self._supervisor is not None:
+            self._supervisor.poll(server_dicts)
+            for d in server_dicts:
+                d["run_id"] = self._supervisor.run_for_pid(d["pid"])
+
         docker_dicts = [_with_project(_asdict(c), c.compose_working_dir) for c in docker]
         claude = self._claude_payload() if self._has_claude and self._tick % CLAUDE_REFRESH_EVERY == 0 else None
         roots = {s.project_root for s in servers} | {d["project_root"] for d in docker_dicts} | self._claude_roots
+        with self._state_lock:
+            self._snapshot_roots = roots - {""}
+            self._busy_cwds = [s.cwd_full for s in servers] + list(self._claude_cwds)
+            self._servers = server_dicts
+        if self._tick % CLAUDE_REFRESH_EVERY == 0:
+            self._refresh_runnable()
 
         snapshot = {
             "type": "snapshot",
             "timestamp": time.time(),
             "system": _asdict(stats),
             "node": node,
-            "servers": [_asdict(s) for s in servers],
+            "servers": server_dicts,
+            "runs": self._supervisor.payload() if self._supervisor is not None else [],
+            "lan_ip": lan_ip(),
             "projects": project_infos(roots - {""}),
             "docker": docker_dicts,
             "processes": [_asdict(p) for p in all_procs],
@@ -183,6 +221,12 @@ def _snapshot(self) -> dict:
             if self._usage_version != self._usage_sent:
                 snapshot["usage"] = self._usage_payload
                 self._usage_sent = self._usage_version
+            if self._worktrees_version != self._worktrees_sent:
+                snapshot["worktrees"] = self._worktrees_payload
+                self._worktrees_sent = self._worktrees_version
+            if self._runnable_version != self._runnable_sent:
+                snapshot["runnable"] = self._runnable_payload
+                self._runnable_sent = self._runnable_version
         self._tick += 1
         return snapshot
 
@@ -201,6 +245,7 @@ def _claude_payload(self) -> dict:
             d["expected_profile"] = profiles.route(d["cwd_full"])
             instances.append(_with_project(d, d["cwd_full"]))
         self._claude_roots = {d["project_root"] for d in instances}
+        self._claude_cwds = [d["cwd_full"] for d in instances]
         return {
             "profile": selected.name,
             "profiles": [
@@ -220,6 +265,129 @@ def _claude_payload(self) -> dict:
             "stats": _claude_stats_payload(get_claude_stats(selected.dir)),
         }
 
+    # -- worktrees -----------------------------------------------------------
+
+    def _worktree_candidates(self) -> set[str]:
+        """Folders to look for repositories in: projects on screen, and the Claude projects of every
+        profile. Also notes the most recent Claude projects, which are offered under "Ready to run"."""
+        with self._state_lock:
+            paths = set(self._snapshot_roots)
+        recent: set[str] = set()
+        for profile in self._profiles.profiles:
+            if profile.dir.is_dir():
+                try:
+                    projects = get_claude_projects(profile.dir)
+                except Exception:
+                    continue
+                paths |= {p.path for p in projects}
+                recent |= {p.path for p in projects[:RECENT_PROJECTS]}
+        with self._state_lock:
+            self._recent_roots = {root for root in (resolve_project(p).root for p in recent) if root}
+        return paths
+
+    def _refresh_worktrees(self) -> None:
+        payload = [_asdict(r) for r in worktrees.scan(self._worktree_candidates())]
+        with self._state_lock:
+            if payload != self._worktrees_payload:
+                self._worktrees_payload = payload
+                self._worktrees_version += 1
+
+    def _worktrees_loop(self) -> None:
+        time.sleep(2)  # let the first snapshot fill in the project roots
+        while not self._stop.is_set():
+            try:
+                self._refresh_worktrees()
+                self._refresh_runnable()  # the scan also updates the recent Claude projects
+            except Exception as e:
+                self.emit({"type": "error", "message": f"worktree scan failed: {e}"})
+            self._worktrees_wake.wait(WORKTREES_REFRESH_SECONDS)
+            self._worktrees_wake.clear()
+
+    def _cmd_refresh_worktrees(self, cmd: dict):
+        self._refresh_worktrees()
+        self._wake.set()
+        return None
+
+    def _cmd_worktree_size(self, cmd: dict):
+        return worktrees.size_bytes(str(cmd["path"]))
+
+    def _cmd_remove_worktree(self, cmd: dict):
+        with self._state_lock:
+            busy = list(self._busy_cwds)
+        result = worktrees.remove(str(cmd["path"]), bool(cmd.get("delete_branch")), busy)
+        self._refresh_worktrees()
+        self._wake.set()
+        return result
+
+    # -- running scripts -----------------------------------------------------
+
+    def _refresh_runnable(self) -> None:
+        """Scripts of every project on screen, every project with a run, and the recent Claude projects."""
+        if self._supervisor is None:
+            return
+        with self._state_lock:
+            on_screen = set(self._snapshot_roots)
+            recent = set(self._recent_roots)
+        runs = {r["project_root"] for r in self._supervisor.payload()}
+        payload = []
+        for root in sorted(on_screen | recent | runs):
+            scripts = runnable.scripts(root)
+            if not scripts:
+                continue
+            default = runnable.default_script(scripts, self._supervisor.last.get(root))
+            payload.append({
+                "root": root,
+                "name": resolve_project(root).name or Path(root).name,
+                "scripts": [_asdict(s) for s in scripts],
+                "default": default.id if default else None,
+                "recent": root in recent and root not in on_screen,
+            })
+        with self._state_lock:
+            if payload != self._runnable_payload:
+                self._runnable_payload = payload
+                self._runnable_version += 1
+
+    def _require_supervisor(self) -> Supervisor:
+        if self._supervisor is None:
+            raise RuntimeError("Running scripts isn't available")
+        return self._supervisor
+
+    def _cmd_run_script(self, cmd: dict):
+        """Starts a script. With `stop_pid`, first stops the process holding its port."""
+        supervisor = self._require_supervisor()
+        if cmd.get("stop_pid"):
+            pid = int(cmd["stop_pid"])
+            if not kill_process(pid):
+                raise RuntimeError(f"Could not stop PID {pid}")
+        root = str(cmd["root"])
+        with self._state_lock:
+            servers = list(self._servers)
+        try:
+            run = supervisor.start(root, str(cmd["script"]), resolve_project(root).name, servers)
+        except PortConflict as conflict:
+            return {"run": None, "conflict": dataclasses.asdict(conflict)}
+        self._refresh_runnable()
+        return {"run": _asdict(run), "conflict": None}
+
+    def _cmd_stop_run(self, cmd: dict):
+        return _asdict(self._require_supervisor().stop(str(cmd["run"])))
+
+    def _cmd_restart_run(self, cmd: dict):
+        with self._state_lock:
+            servers = list(self._servers)
+        try:
+            run = self._require_supervisor().restart(str(cmd["run"]), servers)
+        except PortConflict as conflict:
+            return {"run": None, "conflict": dataclasses.asdict(conflict)}
+        return {"run": _asdict(run), "conflict": None}
+
+    def _cmd_clear_run(self, cmd: dict):
+        self._require_supervisor().clear(str(cmd["run"]))
+        return None
+
+    def _cmd_restart_on_crash(self, cmd: dict):
+        return _asdict(self._require_supervisor().set_restart_on_crash(str(cmd["run"]), bool(cmd.get("on"))))
+
     # -- usage ---------------------------------------------------------------
 
     def _usage_loop(self) -> None:
@@ -440,6 +608,11 @@ def __init__(self, config: Config) -> None:
         self._has_claude = True
         self._usage_enabled = False
         self._profile = "personal"
+        from devdash import demo
+        demo.write_run_logs()
+
+    def _create_supervisor(self) -> Supervisor | None:
+        return None  # never touch the real runs in demo mode
 
     def _snapshot(self) -> dict:
         from devdash import demo
@@ -450,6 +623,8 @@ def _snapshot(self) -> dict:
             "system": demo.system(),
             "node": demo.node(),
             "servers": demo.servers(),
+            "runs": demo.runs(),
+            "lan_ip": demo.LAN_IP,
             "projects": demo.projects(),
             # Demo paths do not exist, so the Compose working dir stands in for the resolved project.
             "docker": [
@@ -462,6 +637,8 @@ def _snapshot(self) -> dict:
         if self._tick % CLAUDE_REFRESH_EVERY == 0:
             snapshot["claude"] = self._cmd_refresh_claude({})
             snapshot["usage"] = demo.usage()
+            snapshot["worktrees"] = demo.worktrees()
+            snapshot["runnable"] = demo.runnable()
         self._tick += 1
         return snapshot
 
@@ -507,10 +684,59 @@ def _cmd_project_detail(self, cmd: dict):
         from devdash import demo
         return demo.project_detail(str(cmd["path"]))
 
+    def _worktrees_loop(self) -> None:
+        pass  # never scan the real repositories in demo mode
+
+    def _cmd_refresh_worktrees(self, cmd: dict):
+        return None
+
+    def _cmd_worktree_size(self, cmd: dict):
+        from devdash import demo
+        return demo.worktree_size(str(cmd["path"]))
+
+    def _cmd_remove_worktree(self, cmd: dict):
+        return {"path": cmd["path"], "branch": "", "branch_deleted": bool(cmd.get("delete_branch")), "note": ""}
+
     def _cmd_project_sessions(self, cmd: dict):
         from devdash import demo
         return demo.project_detail(str(cmd["path"]))["recent_sessions"]
 
+    def _demo_run(self, run_id: str) -> dict:
+        from devdash import demo
+        run = next((r for r in demo.runs() if r["id"] == run_id), None)
+        if run is None:
+            raise RuntimeError("Not a run devdash started")
+        return {**run, "status": "running", "exit_code": None}
+
+    def _cmd_run_script(self, cmd: dict):
+        from devdash import demo
+        root, script = str(cmd["root"]), str(cmd["script"])
+        entry = next((e for e in demo.runnable() if e["root"] == root), None)
+        found = next((s for s in (entry or {}).get("scripts", []) if s["id"] == script), None)
+        if entry is None or found is None:
+            raise RuntimeError(f"No script {script} in {root}")
+        if entry["name"] == "admin" and not cmd.get("stop_pid"):
+            # Shows the port check: admin's dev server wants the port storefront's Next.js holds.
+            return {"run": None, "conflict": {"port": 3000, "pid": 41822, "label": "next dev", "project": "storefront"}}
+        return {"run": {
+            "id": f"{root}#{script}", "project_root": root, "project_name": entry["name"], "script_id": script,
+            "name": found["name"], "command": found["command"], "cwd": found["cwd"], "package": found["package"],
+            "log": f"{demo.RUN_LOG_DIR}/storefront-dev.log", "pid": 70001, "started": time.time(), "status": "running",
+            "exit_code": None, "ended": 0.0, "restart_on_crash": False, "restarts": [], "gave_up": False, "ports": [],
+        }, "conflict": None}
+
+    def _cmd_stop_run(self, cmd: dict):
+        return self._demo_run(str(cmd["run"]))
+
+    def _cmd_restart_run(self, cmd: dict):
+        return {"run": self._demo_run(str(cmd["run"])), "conflict": None}
+
+    def _cmd_clear_run(self, cmd: dict):
+        return None
+
+    def _cmd_restart_on_crash(self, cmd: dict):
+        return {**self._demo_run(str(cmd["run"])), "restart_on_crash": bool(cmd.get("on"))}
+
 
 def serve(config: Config, demo: bool = False) -> None:
     # DEVDASH_DEMO lets a parent process (the menu bar app) opt in without changing arguments.
diff --git a/devdash/demo.py b/devdash/demo.py
index 5a9b940..55d2b36 100644
--- a/devdash/demo.py
+++ b/devdash/demo.py
@@ -9,6 +9,8 @@
 import time
 from datetime import date, datetime, timedelta
 
+from devdash.network import expose_hint
+
 HOME = "/Users/demo"
 _START = time.time()
 
@@ -44,6 +46,10 @@ def _wave(base: float, spread: float, period: float = 30.0, phase: float = 0.0)
     (27640, "vite", "node", "background", "vite --port 5173", "~/code/old-prototype", [], "4d 6h", 88.0, 0.0, "~/code/old-prototype", "old-prototype", ""),
 ]
 
+LAN_IP = "192.168.1.24"
+# Ports that listen on loopback only, so the screenshots show both states of the QR code.
+LOOPBACK_ONLY = {4000, 8000, 4321, 3306, 33060, 20241}
+
 DOCKER = [
     ("a1b2c3d4e5f6", "storefront-postgres-1", "postgres:17", "Up 2 hours (healthy)", "0.0.0.0:5432->5432/tcp", "2 hours ago", "storefront", "postgres"),
     ("b2c3d4e5f6a7", "storefront-redis-1", "redis:7-alpine", "Up 2 hours", "0.0.0.0:6379->6379/tcp", "2 hours ago", "storefront", "redis"),
@@ -104,6 +110,16 @@ def servers() -> list[dict]:
             "memory_mb": mem + random.uniform(-4, 4), "ports": ports, "uptime": uptime,
             "started": now - 600 * (i + 1), "cwd": cwd, "cwd_full": _full(cwd),
             "project_root": _full(root), "project_name": project, "package": package,
+            "urls": [
+                {"port": port, "local": f"http://localhost:{port}",
+                 "lan": None if port in LOOPBACK_ONLY else f"http://{LAN_IP}:{port}",
+                 "exposed": port not in LOOPBACK_ONLY}
+                for port in ports
+            ],
+            "expose_hint": next(
+                (expose_hint(label, command, port) for port in ports if port in LOOPBACK_ONLY), ""
+            ),
+            "run_id": MANAGED_PIDS.get(pid),
         })
     return result
 
@@ -303,3 +319,158 @@ def project_detail(path: str) -> dict:
         "memory_content": "# Memory\n\n- Checkout uses Stripe payment intents, not charges.\n- Run `pnpm test --filter web` before pushing.\n",
         "recent_sessions": [_session(i, *s) for i, s in enumerate(SESSIONS) if s[1] == name] or [_session(0, *SESSIONS[0])],
     }
+
+
+# repo, path (relative to ~), branch, changes, merged, upstream gone, days since touched, days since commit, subject, by
+WORKTREES = [
+    ("storefront", "code/storefront", "feat/checkout", 0, False, False, 0.01, 0.1, "Show the tax line in the cart", ""),
+    ("storefront", "code/storefront/.claude/worktrees/agent-3f9a1c", "claude/fix-cart-total", 3, False, False, 0.02, 0.2, "Round cart totals per line", "claude"),
+    ("storefront", "code/storefront/.claude/worktrees/agent-7b2e04", "claude/onboarding-copy", 0, True, True, 3, 3, "Tighten the onboarding copy", "claude"),
+    ("storefront", "code/storefront-search", "feat/search", 0, True, False, 9, 11, "Search with typo tolerance", ""),
+    ("storefront", "conductor/workspaces/storefront/lisbon", "demo/lisbon", 0, False, False, 12, 14, "Try a sticky checkout bar", "conductor"),
+    ("analytics", "code/analytics", "perf/events", 0, False, False, 0.05, 0.3, "Batch event inserts", ""),
+    ("analytics", "code/analytics/.claude/worktrees/agent-c41d2e", "claude/clickhouse-ttl", 0, True, True, 2, 2, "Add a TTL to raw events", "claude"),
+]
+WORKTREE_SIZES = [412, 1830, 1460, 2210, 980, 96, 120]  # MB
+
+
+def worktrees() -> list[dict]:
+    now = time.time()
+    repos: dict[str, dict] = {}
+    for i, (repo, path, branch, changes, merged, gone, touched, committed, subject, by) in enumerate(WORKTREES):
+        entry = repos.setdefault(repo, {"root": f"{HOME}/{path}", "name": repo, "default_branch": "origin/main", "worktrees": []})
+        is_main = not entry["worktrees"]
+        if changes:
+            status = "changes"
+        elif merged:
+            status = "merged"
+        elif touched > 7:
+            status = "stale"
+        else:
+            status = "active"
+        entry["worktrees"].append({
+            "path": f"{HOME}/{path}", "branch": branch, "head": f"{0x3a7f21c + i * 7919:07x}"[:7], "is_main": is_main,
+            "locked": False, "prunable": False, "changes": changes, "merged": merged, "upstream_gone": gone,
+            "last_commit": now - committed * 86400, "subject": subject, "last_touched": now - touched * 86400,
+            "created_by": by, "status": status,
+        })
+    return list(repos.values())
+
+
+def worktree_size(path: str) -> int | None:
+    for (_, rel, *_), mb in zip(WORKTREES, WORKTREE_SIZES):
+        if path == f"{HOME}/{rel}":
+            return mb * 1024 * 1024
+    return None
+
+
+# -- managed runs --------------------------------------------------------------
+
+# Runs devdash started: storefront's `pnpm run dev` (turbo, which starts web and api) and a crashed worker.
+RUN_LOG_DIR = "/tmp/devdash-demo-runs"
+STOREFRONT_RUN = f"{HOME}/code/storefront#dev"
+WORKER_RUN = f"{HOME}/code/analytics#Procfile.dev:worker"
+MANAGED_PIDS = {41822: STOREFRONT_RUN, 41907: STOREFRONT_RUN}
+
+RUN_LOGS = {
+    "storefront-dev.log": """
+--- devdash: pnpm run dev in /Users/demo/code/storefront at 2026-10-24 09:12:03 ---
+
+> storefront@0.0.0 dev /Users/demo/code/storefront
+> turbo dev
+
+• Packages in scope: api, ui, web
+• Running dev in 3 packages
+api:dev: > node --watch src/server.ts
+web:dev: > next dev --turbo
+web:dev:    ▲ Next.js 16.0.1 (Turbopack)
+web:dev:    - Local:        http://localhost:3000
+web:dev:    - Network:      http://192.168.1.24:3000
+web:dev:  ✓ Ready in 1.2s
+api:dev: Listening on http://localhost:4000
+api:dev: GET /health 200 2ms
+web:dev:  ○ Compiling /checkout ...
+web:dev:  ✓ Compiled /checkout in 840ms
+web:dev:  GET /checkout 200 in 912ms
+api:dev: POST /cart/items 201 14ms
+api:dev: warn: slow query on carts (212ms)
+web:dev:  GET /api/cart 200 in 38ms
+""",
+    "analytics-worker.log": """
+--- devdash: celery -A app.worker worker --loglevel=info in /Users/demo/code/analytics at 2026-10-24 10:41:17 ---
+[2026-10-24 10:41:19,204: INFO/MainProcess] Connected to redis://localhost:6379/0
+[2026-10-24 10:41:19,231: INFO/MainProcess] celery@demo ready.
+[2026-10-24 10:52:03,118: INFO/MainProcess] Task app.tasks.rollup_events received
+[2026-10-24 10:52:04,902: ERROR/ForkPoolWorker-1] Task app.tasks.rollup_events raised unexpected: ConnectionRefusedError(61, 'Connection refused')
+Traceback (most recent call last):
+  File "/Users/demo/code/analytics/app/tasks.py", line 48, in rollup_events
+    client.execute(ROLLUP_SQL)
+ConnectionRefusedError: [Errno 61] Connection refused
+[2026-10-24 10:52:05,011: CRITICAL/MainProcess] Unrecoverable error: ClickHouse at localhost:8123 is unreachable
+""",
+}
+
+
+def write_run_logs() -> None:
+    import os
+    os.makedirs(RUN_LOG_DIR, exist_ok=True)
+    for name, text in RUN_LOGS.items():
+        with open(os.path.join(RUN_LOG_DIR, name), "w", encoding="utf-8") as f:
+            f.write(text.lstrip("\n"))
+
+
+def runs() -> list[dict]:
+    now = _START  # fixed, so a dismissed crash stays dismissed
+    return [
+        {
+            "id": STOREFRONT_RUN, "project_root": f"{HOME}/code/storefront", "project_name": "storefront",
+            "script_id": "dev", "name": "dev", "command": "pnpm run dev", "cwd": f"{HOME}/code/storefront",
+            "package": "", "log": f"{RUN_LOG_DIR}/storefront-dev.log", "pid": 41800, "started": now - 8040,
+            "status": "running", "exit_code": None, "ended": 0.0, "restart_on_crash": True, "restarts": [],
+            "gave_up": False, "ports": [3000, 4000],
+        },
+        {
+            "id": WORKER_RUN, "project_root": f"{HOME}/code/analytics", "project_name": "analytics",
+            "script_id": "Procfile.dev:worker", "name": "worker", "command": "celery -A app.worker worker --loglevel=info",
+            "cwd": f"{HOME}/code/analytics", "package": "", "log": f"{RUN_LOG_DIR}/analytics-worker.log",
+            "pid": 61520, "started": now - 1100, "status": "crashed", "exit_code": 1, "ended": now - 240,
+            "restart_on_crash": False, "restarts": [], "gave_up": False, "ports": [],
+        },
+    ]
+
+
+def _scripts(root: str, manager: str, names: list[str], cwd: str = "", package: str = "") -> list[dict]:
+    rel = cwd.removeprefix(root).strip("/") if cwd else ""
+    return [
+        {"id": f"{rel}:{n}" if rel else n, "name": n, "command": f"{manager} run {n}", "source": "package.json",
+         "cwd": cwd or root, "package": package}
+        for n in names
+    ]
+
+
+def runnable() -> list[dict]:
+    code = f"{HOME}/code"
+    sf = f"{code}/storefront"
+    analytics_procfile = [
+        {"id": f"Procfile.dev:{name}", "name": name, "command": command, "source": "Procfile.dev",
+         "cwd": f"{code}/analytics", "package": ""}
+        for name, command in (
+            ("web", "uvicorn app.main:app --reload --port 8000"),
+            ("worker", "celery -A app.worker worker --loglevel=info"),
+        )
+    ]
+    entries = [
+        (sf, "storefront", _scripts(sf, "pnpm", ["dev", "start", "build", "lint", "test", "db:migrate"])
+            + _scripts(sf, "pnpm", ["dev", "start"], f"{sf}/apps/web", "web")
+            + _scripts(sf, "pnpm", ["dev"], f"{sf}/apps/api", "api"), "dev", False),
+        (f"{code}/design-system", "design-system", _scripts(f"{code}/design-system", "npm", ["storybook", "build", "test"]), "storybook", False),
+        (f"{code}/docs", "docs", _scripts(f"{code}/docs", "pnpm", ["dev", "preview", "build"]), "dev", False),
+        (f"{code}/analytics", "analytics", analytics_procfile, "Procfile.dev:web", False),
+        (f"{code}/mobile-app", "mobile-app", _scripts(f"{code}/mobile-app", "bun", ["start", "ios", "android", "web", "lint"]), "start", True),
+        (f"{code}/marketing-site", "marketing-site", _scripts(f"{code}/marketing-site", "pnpm", ["dev", "preview", "build"]), "dev", True),
+        (f"{code}/admin", "admin", _scripts(f"{code}/admin", "yarn", ["dev", "build", "test"]), "dev", True),
+    ]
+    return [
+        {"root": root, "name": name, "scripts": scripts, "default": default, "recent": recent}
+        for root, name, scripts, default, recent in entries
+    ]
diff --git a/devdash/network.py b/devdash/network.py
new file mode 100644
index 0000000..ca3e440
--- /dev/null
+++ b/devdash/network.py
@@ -0,0 +1,144 @@
+"""Local and network URLs for dev servers.
+
+A server is reachable from other devices (a phone on the same Wi-Fi) only when it listens on all
+interfaces or on the Mac's LAN address. Most dev servers listen on loopback by default.
+"""
+from __future__ import annotations
+
+import ipaddress
+import re
+import socket
+import ssl
+import time
+
+import psutil
+
+LAN_IP_TTL = 30.0
+PROBE_TIMEOUT = 0.1
+
+_lan_ip: tuple[float, str | None] = (0.0, None)
+_tls_cache: dict[tuple[int, int], bool] = {}
+
+
+def pick_lan_ip(addrs: dict, stats: dict) -> str | None:
+    """The first private IPv4 address on an `en*` interface that is up (Wi-Fi or Ethernet).
+
+    VPN tunnels (`utun*`), bridges and loopback are skipped: a phone can't reach those.
+    """
+    for name in sorted(addrs):
+        if not name.startswith("en"):
+            continue
+        stat = stats.get(name)
+        if stat is None or not stat.isup:
+            continue
+        for addr in addrs[name]:
+            if addr.family != socket.AF_INET:
+                continue
+            try:
+                ip = ipaddress.IPv4Address(addr.address)
+            except ValueError:
+                continue
+            if ip.is_private and not ip.is_loopback and not ip.is_link_local:
+                return str(ip)
+    return None
+
+
+def lan_ip() -> str | None:
+    """The Mac's address on the local network, cached for 30 seconds."""
+    global _lan_ip
+    checked, ip = _lan_ip
+    if time.monotonic() - checked < LAN_IP_TTL:
+        return ip
+    try:
+        ip = pick_lan_ip(psutil.net_if_addrs(), psutil.net_if_stats())
+    except (OSError, psutil.Error):
+        ip = None
+    _lan_ip = (time.monotonic(), ip)
+    return ip
+
+
+def is_exposed(bind_ips: set[str], lan: str | None) -> bool:
+    """Whether a port bound to these addresses accepts connections from other devices."""
+    for raw in bind_ips:
+        ip = raw.split("%", 1)[0]  # fe80::1%lo0
+        if ip in ("0.0.0.0", "::", "*", ""):
+            return True
+        if lan is not None and ip == lan:
+            return True
+        try:
+            # Link-local addresses (fe80::1%lo0) aren't what a phone connects to either.
+            addr = ipaddress.ip_address(ip)
+            if not addr.is_loopback and not addr.is_link_local:
+                return True
+        except ValueError:
+            continue
+    return False
+
+
+def _speaks_tls(pid: int, port: int, bind_ips: set[str]) -> bool:
+    """A quick TLS handshake against the port, cached per process and port, so Vite with
+    `--https` gets an https link."""
+    key = (pid, port)
+    if key in _tls_cache:
+        return _tls_cache[key]
+    host = "::1" if bind_ips and all(":" in ip for ip in bind_ips) else "127.0.0.1"
+    context = ssl.create_default_context()
+    context.check_hostname = False
+    context.verify_mode = ssl.CERT_NONE
+    result = False
+    try:
+        with socket.create_connection((host, port), timeout=PROBE_TIMEOUT) as sock:
+            with context.wrap_socket(sock, server_hostname="localhost"):
+                result = True
+    except (OSError, ssl.SSLError, ValueError):
+        result = False
+    _tls_cache[key] = result
+    return result
+
+
+def forget_exited(pids: set[int]) -> None:
+    """Drop probe results for processes that are gone, so a reused PID gets probed again."""
+    for key in [k for k in _tls_cache if k[0] not in pids]:
+        del _tls_cache[key]
+
+
+def server_urls(pid: int, binds: dict[int, set[str]], probe_tls: bool) -> list[dict]:
+    """One entry per listening port: the localhost URL, and the network URL when other devices can
+    reach it. `exposed` is false for ports bound to loopback only; `lan` is also empty when the Mac
+    isn't on a network."""
+    lan = lan_ip()
+    urls = []
+    for port in sorted(binds):
+        ips = binds[port]
+        scheme = "https" if probe_tls and _speaks_tls(pid, port, ips) else "http"
+        exposed = is_exposed(ips, lan)
+        urls.append({
+            "port": port,
+            "local": f"{scheme}://localhost:{port}",
+            "lan": f"{scheme}://{lan}:{port}" if exposed and lan else None,
+            "exposed": exposed,
+        })
+    return urls
+
+
+# Matched against the label and command, first match wins.
+_EXPOSE_HINTS = (
+    (re.compile(r"\bvite\b|\bastro\b|\bnuxt\b|\bsvelte-kit\b|\bremix\b"), "Restart it with --host, for example npm run dev -- --host"),
+    (re.compile(r"\bnext\b"), "Restart it with -H 0.0.0.0, for example npm run dev -- -H 0.0.0.0"),
+    (re.compile(r"\bng serve\b|@angular|\brsbuild\b|\bstorybook\b|webpack"), "Restart it with --host 0.0.0.0"),
+    (re.compile(r"\buvicorn\b|\bfastapi\b|\bflask\b|\bhypercorn\b|\bgranian\b"), "Restart it with --host 0.0.0.0"),
+    (re.compile(r"\bgunicorn\b"), "Restart it with --bind 0.0.0.0:PORT"),
+    (re.compile(r"\bmanage\.py runserver\b|\brunserver\b"), "Restart it with runserver 0.0.0.0:PORT"),
+    (re.compile(r"\brails\b|\bpuma\b"), "Restart it with -b 0.0.0.0"),
+    (re.compile(r"\bphp artisan serve\b|\bartisan serve\b"), "Restart it with --host=0.0.0.0"),
+    (re.compile(r"\bhugo\b"), "Restart it with --bind 0.0.0.0"),
+)
+
+
+def expose_hint(label: str, command: str, port: int) -> str:
+    """How to make a loopback-only server reachable from other devices."""
+    text = f"{label} {command}".lower()
+    for pattern, hint in _EXPOSE_HINTS:
+        if pattern.search(text):
+            return hint.replace("PORT", str(port))
+    return "Make it listen on 0.0.0.0 instead of localhost or 127.0.0.1"
diff --git a/devdash/runnable.py b/devdash/runnable.py
new file mode 100644
index 0000000..5a65777
--- /dev/null
+++ b/devdash/runnable.py
@@ -0,0 +1,200 @@
+"""What a project can run: package.json scripts and Procfile entries.
+
+Used by the supervisor to start dev servers, and by the menu bar app to list them.
+"""
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+# Scripts that usually start a server come first, in this order. The rest keep their file order.
+PREFERRED = ("dev", "start", "serve", "preview")
+
+# npm lifecycle scripts: they run on install and publish, not by hand.
+LIFECYCLE = {
+    "preinstall", "install", "postinstall", "prepare", "prepublish", "prepublishOnly", "prepack",
+    "postpack", "publish", "postpublish", "preversion", "version", "postversion", "dependencies",
+}
+
+LOCKFILES = (
+    ("pnpm-lock.yaml", "pnpm"), ("yarn.lock", "yarn"), ("bun.lock", "bun"), ("bun.lockb", "bun"),
+    ("package-lock.json", "npm"),
+)
+
+PROCFILES = ("Procfile.dev", "Procfile")
+MAX_PACKAGES = 30
+
+
+@dataclass
+class Script:
+    id: str  # unique within the project: "dev", "apps/web:dev", "Procfile.dev:web"
+    name: str
+    command: str  # what runs, through the shell
+    source: str  # "package.json", "Procfile.dev" or "Procfile"
+    cwd: str
+    package: str = ""  # workspace package name, for scripts of a package inside the project
+
+
+def _read_json(path: Path) -> dict:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        return data if isinstance(data, dict) else {}
+    except (OSError, ValueError):
+        return {}
+
+
+def package_manager(folder: Path, root: Path) -> str:
+    """From the `packageManager` field, else the nearest lockfile between the folder and the
+    project root (workspaces keep one lockfile at the root), else npm."""
+    for candidate in [folder, *folder.parents]:
+        field = str(_read_json(candidate / "package.json").get("packageManager") or "")
+        if field:
+            name = field.split("@", 1)[0]
+            if name in ("npm", "pnpm", "yarn", "bun"):
+                return name
+        for filename, manager in LOCKFILES:
+            if (candidate / filename).exists():
+                return manager
+        if candidate == root or root not in candidate.parents:
+            break
+    return "npm"
+
+
+def _ordered(names: list[str]) -> list[str]:
+    names = [n for n in names if n not in LIFECYCLE]
+    present = set(names)
+    # `predev` and `postdev` run around `dev` on their own.
+    names = [n for n in names if not (re.match(r"^(pre|post)", n) and re.sub(r"^(pre|post)", "", n) in present)]
+    first = [n for n in PREFERRED if n in present]
+    return first + [n for n in names if n not in first]
+
+
+def _package_scripts(folder: Path, root: Path, only_preferred: bool) -> list[Script]:
+    data = _read_json(folder / "package.json")
+    scripts = data.get("scripts")
+    if not isinstance(scripts, dict):
+        return []
+    manager = package_manager(folder, root)
+    names = _ordered([str(k) for k, v in scripts.items() if isinstance(v, str)])
+    if only_preferred:
+        names = [n for n in names if n in PREFERRED]
+    rel = "" if folder == root else str(folder.relative_to(root))
+    package = "" if folder == root else str(data.get("name") or folder.name)
+    return [
+        Script(
+            id=f"{rel}:{name}" if rel else name,
+            name=name,
+            command=f"{manager} run {name}",
+            source="package.json",
+            cwd=str(folder),
+            package=package,
+        )
+        for name in names
+    ]
+
+
+def _workspace_globs(root: Path) -> list[str]:
+    globs: list[str] = []
+    workspaces = _read_json(root / "package.json").get("workspaces")
+    if isinstance(workspaces, dict):  # yarn's {"packages": [...]}
+        workspaces = workspaces.get("packages")
+    if isinstance(workspaces, list):
+        globs += [str(w) for w in workspaces]
+    try:
+        # pnpm-workspace.yaml: a "packages:" list. Read by hand to avoid a YAML dependency.
+        in_packages = False
+        for line in (root / "pnpm-workspace.yaml").read_text(encoding="utf-8").splitlines():
+            if re.match(r"^\S", line):
+                in_packages = line.startswith("packages:")
+                continue
+            match = re.match(r"^\s*-\s*['\"]?([^'\"#]+?)['\"]?\s*(#.*)?$", line)
+            if in_packages and match:
+                globs.append(match.group(1))
+    except OSError:
+        pass
+    return [g for g in globs if not g.startswith("!")]
+
+
+def workspace_packages(root: Path) -> list[Path]:
+    """Folders of the workspace packages, from package.json `workspaces` or pnpm-workspace.yaml."""
+    found: list[Path] = []
+    for pattern in _workspace_globs(root):
+        pattern = pattern.rstrip("/")
+        try:
+            matches = sorted(root.glob(pattern)) if any(c in pattern for c in "*?[") else [root / pattern]
+        except (ValueError, NotImplementedError):
+            continue
+        for folder in matches:
+            if "node_modules" in folder.parts or folder == root or folder in found:
+                continue
+            if (folder / "package.json").is_file():
+                found.append(folder)
+            if len(found) >= MAX_PACKAGES:
+                return found
+    return found
+
+
+def _procfile_scripts(root: Path) -> list[Script]:
+    for filename in PROCFILES:
+        try:
+            lines = (root / filename).read_text(encoding="utf-8").splitlines()
+        except OSError:
+            continue
+        scripts = []
+        for line in lines:
+            match = re.match(r"^([A-Za-z0-9_-]+):\s*(.+)$", line.strip())
+            if match:
+                name, command = match.groups()
+                scripts.append(Script(
+                    id=f"{filename}:{name}", name=name, command=command.strip(), source=filename, cwd=str(root),
+                ))
+        return scripts  # the first Procfile found wins, like foreman
+    return []
+
+
+def scripts(root: str) -> list[Script]:
+    """Everything a project can run: the root package.json scripts, the server scripts of its
+    workspace packages, and the entries of Procfile.dev or Procfile."""
+    path = Path(root)
+    if not path.is_dir():
+        return []
+    result = _package_scripts(path, path, only_preferred=False)
+    for folder in workspace_packages(path):
+        result += _package_scripts(folder, path, only_preferred=True)
+    result += _procfile_scripts(path)
+    return result
+
+
+def find(root: str, script_id: str) -> Script | None:
+    return next((s for s in scripts(root) if s.id == script_id), None)
+
+
+def default_script(available: list[Script], last: str | None) -> Script | None:
+    """The script "Run" starts: the one run last time, else the first."""
+    if last:
+        for script in available:
+            if script.id == last:
+                return script
+    return available[0] if available else None
+
+
+_PORT_PATTERNS = (
+    re.compile(r"(?:--port|-p)[ =](\d{2,5})\b"),
+    re.compile(r"\bPORT=(\d{2,5})\b"),
+    re.compile(r"(?:--bind|-b)[ =][\w.\[\]]*:(\d{2,5})\b"),
+)
+
+
+def ports_in(text: str) -> set[int]:
+    """Ports named in a command: `--port 3000`, `-p 3000`, `PORT=3000`, `--bind 0.0.0.0:8000`."""
+    return {int(m) for pattern in _PORT_PATTERNS for m in pattern.findall(text) if 0 < int(m) < 65536}
+
+
+def script_body(script: Script) -> str:
+    """The command a package.json script actually runs, to look for a port in it."""
+    if script.source != "package.json":
+        return script.command
+    body = (_read_json(Path(script.cwd) / "package.json").get("scripts") or {}).get(script.name)
+    return body if isinstance(body, str) else ""
diff --git a/devdash/servers.py b/devdash/servers.py
index 6e85ec9..cd8463b 100644
--- a/devdash/servers.py
+++ b/devdash/servers.py
@@ -14,6 +14,7 @@
 import psutil
 
 from devdash.config import tomllib
+from devdash.network import expose_hint, forget_exited, server_urls
 from devdash.processes import _format_uptime, _shorten_command, _shorten_cwd
 
 HOME = Path.home()
@@ -71,6 +72,10 @@ class Server:
     project_root: str = ""
     project_name: str = ""
     package: str = ""
+    # Per port: {port, local, lan, exposed}. See devdash.network.server_urls.
+    urls: list[dict] = field(default_factory=list)
+    # How to make loopback-only ports reachable from a phone, when there are any.
+    expose_hint: str = ""
 
 
 # -- projects ----------------------------------------------------------------
@@ -247,10 +252,11 @@ def get_servers(node_pids: set[int], docker_ports: set[int]) -> list[Server]:
             if uids is None or uids.real != uid:
                 continue
             pid = info["pid"]
-            ports = sorted({
-                c.laddr.port for c in proc.net_connections(kind="inet")
-                if c.status == psutil.CONN_LISTEN and c.laddr
-            })
+            binds: dict[int, set[str]] = {}
+            for c in proc.net_connections(kind="inet"):
+                if c.status == psutil.CONN_LISTEN and c.laddr:
+                    binds.setdefault(c.laddr.port, set()).add(c.laddr.ip)
+            ports = sorted(binds)
             if not ports and pid not in node_pids:
                 continue
             if ports and docker_ports and set(ports) <= docker_ports:
@@ -270,14 +276,20 @@ def get_servers(node_pids: set[int], docker_ports: set[int]) -> list[Server]:
                 cpu = proc.cpu_percent(interval=0)
             except (psutil.AccessDenied, psutil.NoSuchProcess):
                 cpu = 0.0
+            kind = _kind(runtime, exe, proc.ppid(), ports, project)
+            label = _label(name, runtime, cmdline)
+            command = _shorten_command(cmdline)
+            # Only apps get the TLS probe: databases log a failed handshake as an error.
+            urls = server_urls(pid, binds, probe_tls=kind == "app")
+            hidden = [u["port"] for u in urls if not u["exposed"]]
 
             results.append(Server(
                 pid=pid,
                 name=name,
-                label=_label(name, runtime, cmdline),
+                label=label,
                 runtime=runtime,
-                kind=_kind(runtime, exe, proc.ppid(), ports, project),
-                command=_shorten_command(cmdline),
+                kind=kind,
+                command=command,
                 cpu_percent=cpu,
                 memory_mb=proc.memory_info().rss / (1024 * 1024),
                 ports=ports,
@@ -288,9 +300,12 @@ def get_servers(node_pids: set[int], docker_ports: set[int]) -> list[Server]:
                 project_root=project.root,
                 project_name=project.name,
                 package=project.package,
+                urls=urls,
+                expose_hint=expose_hint(label, command, hidden[0]) if hidden else "",
             ))
         except (psutil.AccessDenied, psutil.NoSuchProcess, psutil.ZombieProcess, OSError):
             continue
 
+    forget_exited({s.pid for s in results})
     results.sort(key=lambda s: (s.ports[0] if s.ports else 1 << 20, s.pid))
     return results
diff --git a/devdash/supervisor.py b/devdash/supervisor.py
new file mode 100644
index 0000000..0a1d8e2
--- /dev/null
+++ b/devdash/supervisor.py
@@ -0,0 +1,436 @@
+"""Dev servers devdash starts itself ("managed" runs): start, stop, restart, logs, restart on crash.
+
+Runs start detached in their own process group, so they keep running when the menu bar app quits,
+like servers started from a terminal. Their output goes to a log file, and what is running is kept in
+a state file, so a new bridge picks them up again.
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import shutil
+import signal
+import subprocess
+import threading
+import time
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Callable
+
+from devdash import runnable
+
+STATE_DIR = Path.home() / ".local" / "share" / "devdash" / "runs"
+LOG_MAX_BYTES = 5 * 1024 * 1024
+STOP_TIMEOUT = 5.0
+CRASH_DELAY = 2.0
+CRASH_LIMIT = 3  # restarts per window, then devdash gives up
+CRASH_WINDOW = 300.0
+SHELL_ENV_TIMEOUT = 10.0
+
+# Exit codes of a process that was asked to stop (SIGINT, SIGTERM, SIGHUP, directly or through a shell).
+STOPPED_CODES = {-signal.SIGINT, -signal.SIGTERM, -signal.SIGHUP, 128 + signal.SIGINT, 128 + signal.SIGTERM, 128 + signal.SIGHUP}
+
+# The bridge's own environment that must not leak into a dev server.
+DROPPED_ENV = ("PYTHONHOME", "PYTHONPATH", "PYTHONEXECUTABLE", "PYTHONUNBUFFERED", "__PYVENV_LAUNCHER__", "VIRTUAL_ENV")
+
+
+@dataclass
+class Run:
+    id: str  # project root and script id, so running a script again replaces its old run
+    project_root: str
+    project_name: str
+    script_id: str
+    name: str
+    command: str
+    cwd: str
+    package: str
+    log: str
+    pid: int = 0  # also the process group id
+    started: float = 0.0
+    # "running", "restarting" (waiting to restart after a crash), "exited" or "crashed".
+    status: str = "running"
+    exit_code: int | None = None
+    ended: float = 0.0
+    restart_on_crash: bool = False
+    restarts: list[float] = field(default_factory=list)
+    gave_up: bool = False  # crashed too often, restart on crash stopped
+    ports: list[int] = field(default_factory=list)  # ports seen listening, checked before the next start
+
+
+@dataclass
+class PortConflict(Exception):
+    port: int
+    pid: int
+    label: str
+    project: str
+
+    def __str__(self) -> str:
+        where = f" in {self.project}" if self.project else ""
+        return f"Port {self.port} is held by PID {self.pid} ({self.label}{where})"
+
+
+def _slug(text: str) -> str:
+    return re.sub(r"[^A-Za-z0-9._-]+", "-", text).strip("-") or "run"
+
+
+def _group_alive(pgid: int) -> bool:
+    if pgid <= 0:
+        return False
+    try:
+        os.killpg(pgid, 0)
+        return True
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+
+
+def _signal_group(pgid: int, sig: int) -> None:
+    try:
+        os.killpg(pgid, sig)
+    except (ProcessLookupError, PermissionError):
+        pass
+
+
+def _rotate(log: Path) -> None:
+    """Keeps a log under LOG_MAX_BYTES: the old part goes to `.1`. Runs write with O_APPEND, so
+    truncating in place is safe while they keep writing."""
+    try:
+        if log.stat().st_size <= LOG_MAX_BYTES:
+            return
+        shutil.copyfile(log, log.with_name(log.name + ".1"))
+        os.truncate(log, 0)
+    except OSError:
+        pass
+
+
+_shell_env: dict[str, str] | None = None
+_shell_env_lock = threading.Lock()
+
+
+def shell_env() -> dict[str, str]:
+    """The environment of the user's login shell, so version managers (nvm, fnm, mise, asdf) put the
+    right node and python on PATH, as in a terminal. Read once; the bridge's own env if that fails."""
+    global _shell_env
+    with _shell_env_lock:
+        if _shell_env is not None:
+            return dict(_shell_env)
+        base = {k: v for k, v in os.environ.items() if k not in DROPPED_ENV and not k.startswith("DEVDASH_")}
+        env = dict(base)
+        shell = os.environ.get("SHELL") or "/bin/zsh"
+        marker = "__devdash_env__"
+        try:
+            out = subprocess.run(
+                [shell, "-l", "-i", "-c", f"printf {marker}; command env -0"],
+                capture_output=True, timeout=SHELL_ENV_TIMEOUT, stdin=subprocess.DEVNULL, env=base,
+            ).stdout.decode("utf-8", "replace")
+            if marker in out:
+                pairs = (item.partition("=") for item in out.rsplit(marker, 1)[1].split("\0") if "=" in item)
+                parsed = {k: v for k, _, v in pairs if k and k not in DROPPED_ENV and not k.startswith("DEVDASH_")}
+                if parsed.get("PATH"):
+                    env = parsed
+        except (OSError, subprocess.TimeoutExpired):
+            pass
+        for key in ("SHLVL", "_", "OLDPWD", "PWD"):
+            env.pop(key, None)
+        _shell_env = env
+        return dict(env)
+
+
+class Supervisor:
+    def __init__(self, state_dir: Path = STATE_DIR, on_change: Callable[[], None] | None = None,
+                 env: Callable[[], dict[str, str]] = shell_env) -> None:
+        self.state_dir = state_dir
+        self._on_change = on_change or (lambda: None)
+        self._env = env
+        self._lock = threading.RLock()
+        self.runs: dict[str, Run] = {}
+        self.last: dict[str, str] = {}  # project root to the script id run last
+        self._procs: dict[str, subprocess.Popen] = {}
+        self._stopping: set[str] = set()
+        self._load()
+
+    # -- state ---------------------------------------------------------------
+
+    @property
+    def _state_file(self) -> Path:
+        return self.state_dir / "state.json"
+
+    def _load(self) -> None:
+        try:
+            data = json.loads(self._state_file.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            return
+        fields = set(Run.__dataclass_fields__)
+        for item in data.get("runs", []):
+            try:
+                run = Run(**{k: v for k, v in item.items() if k in fields})
+            except TypeError:
+                continue
+            # Not our child any more: no exit code, and no restart on crash until it is started again.
+            if run.status in ("running", "restarting") and not _group_alive(run.pid):
+                run.status, run.ended = "exited", run.ended or time.time()
+            self.runs[run.id] = run
+        self.last = {str(k): str(v) for k, v in (data.get("last") or {}).items()}
+
+    def _save(self) -> None:
+        with self._lock:
+            data = {"runs": [asdict(r) for r in self.runs.values()], "last": self.last}
+        try:
+            self.state_dir.mkdir(parents=True, exist_ok=True)
+            tmp = self._state_file.with_suffix(".tmp")
+            tmp.write_text(json.dumps(data, indent=1), encoding="utf-8")
+            tmp.replace(self._state_file)
+        except OSError:
+            pass
+
+    def payload(self) -> list[dict]:
+        with self._lock:
+            return [asdict(r) for r in sorted(self.runs.values(), key=lambda r: r.started)]
+
+    # -- starting ------------------------------------------------------------
+
+    @staticmethod
+    def run_id(root: str, script_id: str) -> str:
+        return f"{root}#{script_id}"
+
+    def start(self, root: str, script_id: str, project_name: str = "", servers: list[dict] | None = None) -> Run:
+        """Starts a script of a project. Raises PortConflict when a port the script used before (or
+        names in its command) is held by a process devdash didn't start, and ValueError when the
+        script is unknown or already running."""
+        script = runnable.find(root, script_id)
+        if script is None:
+            raise ValueError(f"No script {script_id} in {root}")
+        run_id = self.run_id(root, script_id)
+        with self._lock:
+            old = self.runs.get(run_id)
+            if old and old.status in ("running", "restarting") and _group_alive(old.pid):
+                raise ValueError(f"{script.name} is already running")
+            self._check_ports(old, script, servers or [])
+            run = Run(
+                id=run_id, project_root=root, project_name=project_name or Path(root).name,
+                script_id=script.id, name=script.name, command=script.command, cwd=script.cwd,
+                package=script.package,
+                log=str(self.state_dir / _slug(Path(root).name) / f"{_slug(script.id)}.log"),
+                restart_on_crash=old.restart_on_crash if old else False,
+                ports=old.ports if old else [],
+            )
+            try:
+                self._spawn(run)
+            except OSError as e:
+                raise ValueError(f"Could not start {script.name}: {e.strerror or e}") from e
+            self.runs[run_id] = run
+            self.last[root] = script.id
+        self._save()
+        self._on_change()
+        return run
+
+    def _check_ports(self, old: Run | None, script: runnable.Script, servers: list[dict]) -> None:
+        wanted = set(old.ports if old else []) | runnable.ports_in(runnable.script_body(script))
+        if not wanted:
+            return
+        managed = {r.pid for r in self.runs.values()}
+        for server in servers:
+            group = self._group_of(int(server["pid"]))
+            if not group:
+                continue  # exited since the snapshot, for example a run that was just stopped
+            for port in server.get("ports") or []:
+                if port in wanted and group not in managed:
+                    raise PortConflict(port, int(server["pid"]), server.get("label") or server.get("name") or "",
+                                       server.get("project_name") or "")
+
+    def _spawn(self, run: Run) -> None:
+        log = Path(run.log)
+        log.parent.mkdir(parents=True, exist_ok=True)
+        _rotate(log)
+        env = self._env()
+        env["BROWSER"] = "none"  # don't open a browser tab on every restart (Vite, CRA, Next)
+        stamp = time.strftime("%Y-%m-%d %H:%M:%S")
+        with open(log, "ab") as out:
+            out.write(f"\n--- devdash: {run.command} in {run.cwd} at {stamp} ---\n".encode())
+            out.flush()
+            proc = subprocess.Popen(
+                ["/bin/sh", "-c", run.command], cwd=run.cwd, env=env,
+                stdin=subprocess.DEVNULL, stdout=out, stderr=subprocess.STDOUT, start_new_session=True,
+            )
+        run.pid, run.started, run.status = proc.pid, time.time(), "running"
+        run.exit_code, run.ended = None, 0.0
+        self._procs[run.id] = proc
+        threading.Thread(target=self._watch, args=(run.id, proc), daemon=True).start()
+
+    # -- exits ---------------------------------------------------------------
+
+    def _watch(self, run_id: str, proc: subprocess.Popen) -> None:
+        code = proc.wait()
+        with self._lock:
+            run = self.runs.get(run_id)
+            if run is None or self._procs.get(run_id) is not proc:
+                return
+            self._procs.pop(run_id, None)
+            if run_id in self._stopping:
+                return
+            run.exit_code = code
+            # The shell is gone, but what it started may still be running in the group (npm's child
+            # node, say). poll() finishes the run once the group is empty.
+            if _group_alive(run.pid):
+                return
+        self._finish(run_id)
+
+    def _finish(self, run_id: str) -> None:
+        with self._lock:
+            run = self.runs.get(run_id)
+            if run is None or run.status != "running":
+                return
+            run.ended = time.time()
+            code = run.exit_code
+            if code is None or code == 0 or code in STOPPED_CODES:
+                run.status = "exited"
+            else:
+                run.status = "crashed"
+                # Only runs this bridge started have an exit code, so reloaded runs never get here.
+                if run.restart_on_crash:
+                    now = time.time()
+                    run.restarts = [t for t in run.restarts if now - t < CRASH_WINDOW]
+                    if len(run.restarts) < CRASH_LIMIT:
+                        run.restarts.append(now)
+                        run.status = "restarting"
+                        timer = threading.Timer(CRASH_DELAY, self._respawn, args=(run_id,))
+                        timer.daemon = True
+                        timer.start()
+                    else:
+                        run.gave_up = True
+        self._save()
+        self._on_change()
+
+    def _respawn(self, run_id: str) -> None:
+        with self._lock:
+            run = self.runs.get(run_id)
+            if run is None or run.status != "restarting":
+                return
+            try:
+                self._spawn(run)
+            except OSError:
+                run.status, run.gave_up = "crashed", True
+        self._save()
+        self._on_change()
+
+    def poll(self, servers: list[dict] | None = None) -> bool:
+        """Called on every snapshot: finishes runs whose process group is gone, remembers the ports
+        each run listens on, and keeps logs small. Returns whether anything changed."""
+        changed = False
+        finished = []
+        with self._lock:
+            for run in self.runs.values():
+                if run.status == "running" and not _group_alive(run.pid):
+                    if run.id not in self._procs:  # our own children are finished by _watch
+                        finished.append(run.id)
+                if run.status in ("running", "restarting"):
+                    _rotate(Path(run.log))
+            by_group: dict[int, set[int]] = {}
+            for server in servers or []:
+                if server.get("ports"):
+                    group = self._group_of(int(server["pid"]))
+                    if group:
+                        by_group.setdefault(group, set()).update(server["ports"])
+            for run in self.runs.values():
+                ports = by_group.get(run.pid)
+                if run.status == "running" and ports and sorted(ports) != run.ports:
+                    run.ports = sorted(ports)
+                    changed = True
+        for run_id in finished:
+            self._finish(run_id)
+        if changed:
+            self._save()
+        return changed or bool(finished)
+
+    # -- stopping ------------------------------------------------------------
+
+    def stop(self, run_id: str, forget: bool = True) -> Run:
+        """SIGTERM to the run's process group, SIGKILL after STOP_TIMEOUT. That reaches the children
+        `npm run dev` starts. The run leaves the list unless `forget` is False."""
+        with self._lock:
+            run = self.runs.get(run_id)
+            if run is None:
+                raise ValueError("Not a run devdash started")
+            self._stopping.add(run_id)
+            proc = self._procs.pop(run_id, None)
+            pgid = run.pid
+        try:
+            if run.status in ("running", "restarting"):
+                _signal_group(pgid, signal.SIGTERM)
+                deadline = time.monotonic() + STOP_TIMEOUT
+                while _group_alive(pgid) and time.monotonic() < deadline:
+                    if proc is not None:
+                        proc.poll()  # reap the shell so it doesn't linger as a zombie
+                    time.sleep(0.1)
+                if _group_alive(pgid):
+                    _signal_group(pgid, signal.SIGKILL)
+                    time.sleep(0.2)
+                if proc is not None:
+                    try:
+                        proc.wait(timeout=1)
+                    except subprocess.TimeoutExpired:
+                        pass
+            with self._lock:
+                if forget:
+                    self.runs.pop(run_id, None)
+                else:
+                    run.status, run.ended, run.exit_code = "exited", time.time(), None
+        finally:
+            with self._lock:
+                self._stopping.discard(run_id)
+        self._save()
+        self._on_change()
+        return run
+
+    def restart(self, run_id: str, servers: list[dict] | None = None) -> Run:
+        with self._lock:
+            run = self.runs.get(run_id)
+            if run is None:
+                raise ValueError("Not a run devdash started")
+            root, script_id, name = run.project_root, run.script_id, run.project_name
+        self.stop(run_id, forget=False)
+        return self.start(root, script_id, name, servers)
+
+    def clear(self, run_id: str) -> None:
+        """Removes an exited or crashed run from the list."""
+        with self._lock:
+            run = self.runs.get(run_id)
+            if run is not None and run.status in ("running", "restarting"):
+                raise ValueError(f"{run.name} is still running")
+            self.runs.pop(run_id, None)
+        self._save()
+        self._on_change()
+
+    def set_restart_on_crash(self, run_id: str, on: bool) -> Run:
+        with self._lock:
+            run = self.runs.get(run_id)
+            if run is None:
+                raise ValueError("Not a run devdash started")
+            run.restart_on_crash = on
+            run.gave_up = False
+            run.restarts = []
+        self._save()
+        self._on_change()
+        return run
+
+    # -- matching servers to runs ---------------------------------------------
+
+    @staticmethod
+    def _group_of(pid: int) -> int:
+        try:
+            return os.getpgid(pid)
+        except (ProcessLookupError, PermissionError, OSError):
+            return 0
+
+    def run_for_pid(self, pid: int) -> str | None:
+        """The run a process belongs to, by process group."""
+        group = self._group_of(pid)
+        if not group:
+            return None
+        with self._lock:
+            for run in self.runs.values():
+                if run.pid == group and run.status in ("running", "restarting"):
+                    return run.id
+        return None
diff --git a/devdash/worktrees.py b/devdash/worktrees.py
new file mode 100644
index 0000000..5d16862
--- /dev/null
+++ b/devdash/worktrees.py
@@ -0,0 +1,277 @@
+"""Git worktrees across the repositories devdash knows about.
+
+Coding agents create a worktree per task and rarely remove them. This lists every linked worktree with
+whether it has changes, whether its branch is merged, and how long since it was touched, and removes
+the ones that are safe to remove.
+"""
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+
+GIT_TIMEOUT = 10
+STALE_DAYS = 7
+
+# Path fragments that tell which tool created a worktree, first match wins.
+CREATORS = (
+    ("/.claude/worktrees/", "claude"),
+    ("/.codex/", "codex"),
+    ("/conductor/", "conductor"),
+    ("/.cursor/", "cursor"),
+    ("/.superset/", "superset"),
+    ("/.t3/", "t3code"),
+)
+
+
+@dataclass
+class Worktree:
+    path: str
+    branch: str  # empty when detached
+    head: str  # short commit
+    is_main: bool = False
+    locked: bool = False
+    prunable: bool = False  # the folder is gone
+    changes: int = 0  # changed and untracked files
+    merged: bool = False
+    upstream_gone: bool = False
+    last_commit: float = 0.0
+    subject: str = ""
+    last_touched: float = 0.0
+    created_by: str = ""
+    # "missing", "changes", "merged", "stale" or "active". The menu bar app adds "running" on top.
+    status: str = "active"
+
+
+@dataclass
+class Repo:
+    root: str  # the main worktree
+    name: str
+    default_branch: str
+    worktrees: list[Worktree] = field(default_factory=list)
+
+
+def _git(cwd: str, *args: str) -> str:
+    result = subprocess.run(
+        ["git", "-C", cwd, *args],
+        capture_output=True, text=True, timeout=GIT_TIMEOUT,
+        env={**os.environ, "GIT_OPTIONAL_LOCKS": "0", "LC_ALL": "C"},
+    )
+    if result.returncode != 0:
+        raise RuntimeError(result.stderr.strip() or f"git {args[0]} failed")
+    return result.stdout
+
+
+def parse_porcelain(text: str) -> list[Worktree]:
+    """`git worktree list --porcelain`: blocks separated by blank lines, the main worktree first."""
+    worktrees: list[Worktree] = []
+    for block in text.strip().split("\n\n"):
+        fields: dict[str, str] = {}
+        for line in block.splitlines():
+            key, _, value = line.partition(" ")
+            fields[key] = value
+        if "worktree" not in fields:
+            continue
+        branch = fields.get("branch", "")
+        worktrees.append(Worktree(
+            path=fields["worktree"],
+            branch=branch.removeprefix("refs/heads/"),
+            head=fields.get("HEAD", "")[:7],
+            locked="locked" in fields,
+            prunable="prunable" in fields,
+        ))
+    if worktrees and "bare" not in text.split("\n\n", 1)[0]:
+        worktrees[0].is_main = True
+    return worktrees
+
+
+def created_by(path: str) -> str:
+    for fragment, tool in CREATORS:
+        if fragment in path + "/":
+            return tool
+    return ""
+
+
+def status(wt: Worktree, now: float) -> str:
+    """Priority order: a missing folder, then uncommitted changes, then merged, then age."""
+    if wt.prunable:
+        return "missing"
+    if wt.changes:
+        return "changes"
+    if wt.merged and not wt.is_main:
+        return "merged"
+    if now - max(wt.last_touched, wt.last_commit) > STALE_DAYS * 86400:
+        return "stale"
+    return "active"
+
+
+def _last_touched(path: str) -> float:
+    """Newest modification time among the worktree's top-level entries. Cheap, and enough to tell a
+    worktree someone is working in from one that sat for a week."""
+    newest = 0.0
+    try:
+        with os.scandir(path) as entries:
+            for entry in entries:
+                try:
+                    newest = max(newest, entry.stat(follow_symlinks=False).st_mtime)
+                except OSError:
+                    continue
+    except OSError:
+        pass
+    return newest
+
+
+def _default_branch(root: str) -> str:
+    """The branch merged work lands on: origin's default branch, else origin/main or origin/master,
+    else a local main or master. The remote one first, since the local copy is often behind."""
+    try:
+        return _git(root, "symbolic-ref", "--quiet", "refs/remotes/origin/HEAD").strip().removeprefix("refs/remotes/")
+    except (RuntimeError, subprocess.TimeoutExpired):
+        pass
+    for ref in ("refs/remotes/origin/main", "refs/remotes/origin/master", "refs/heads/main", "refs/heads/master"):
+        try:
+            _git(root, "rev-parse", "--verify", "--quiet", ref)
+            return ref.removeprefix("refs/remotes/").removeprefix("refs/heads/")
+        except (RuntimeError, subprocess.TimeoutExpired):
+            continue
+    return ""
+
+
+_common_dirs: dict[str, str | None] = {}
+
+
+def common_dir(path: str) -> str | None:
+    """The shared `.git` folder of the repository a path is in, so a worktree and its main checkout
+    count as one repository. Cached: a folder doesn't move between repositories."""
+    if path in _common_dirs:
+        return _common_dirs[path]
+    result = None
+    if os.path.isdir(path):
+        try:
+            out = _git(path, "rev-parse", "--path-format=absolute", "--git-common-dir").strip()
+            result = out or None
+        except (RuntimeError, subprocess.TimeoutExpired, OSError):
+            result = None
+    _common_dirs[path] = result
+    return result
+
+
+def scan_repo(git_dir: str, now: float | None = None) -> Repo | None:
+    """Every worktree of one repository, or None when it has no linked worktrees."""
+    now = now or time.time()
+    try:
+        worktrees = parse_porcelain(_git(git_dir, "worktree", "list", "--porcelain"))
+    except (RuntimeError, subprocess.TimeoutExpired, OSError):
+        return None
+    if len(worktrees) < 2:
+        return None
+    main = worktrees[0]
+    root = main.path
+    default = _default_branch(root)
+
+    merged: set[str] = set()
+    tracking: dict[str, tuple[bool, float, str]] = {}
+    try:
+        if default:
+            merged = set(_git(root, "branch", "--merged", default, "--format=%(refname:short)").split())
+        for line in _git(
+            root, "for-each-ref", "refs/heads", "--format=%(refname:short)\t%(upstream:track)\t%(committerdate:unix)\t%(subject)",
+        ).splitlines():
+            name, track, date, subject = (line.split("\t", 3) + ["", "", ""])[:4]
+            tracking[name] = (track == "[gone]", float(date or 0), subject)
+    except (RuntimeError, subprocess.TimeoutExpired):
+        pass
+    default_local = default.split("/", 1)[-1]
+
+    for wt in worktrees:
+        wt.created_by = created_by(wt.path)
+        if wt.branch in tracking:
+            wt.upstream_gone, wt.last_commit, wt.subject = tracking[wt.branch]
+        # A branch that was squash-merged on GitHub isn't an ancestor of main, but its remote branch is gone.
+        wt.merged = bool(wt.branch) and wt.branch != default_local and (wt.branch in merged or wt.upstream_gone)
+        if not wt.prunable:
+            wt.last_touched = _last_touched(wt.path)
+            try:
+                wt.changes = len(_git(wt.path, "status", "--porcelain", "--no-renames").splitlines())
+            except (RuntimeError, subprocess.TimeoutExpired, OSError):
+                wt.changes = 0
+        wt.status = status(wt, now)
+
+    return Repo(root=root, name=Path(root).name, default_branch=default, worktrees=worktrees)
+
+
+def scan(paths: set[str]) -> list[Repo]:
+    """Repositories with linked worktrees among the given folders, deduplicated by repository."""
+    git_dirs = {d for d in (common_dir(p) for p in paths if p) if d}
+    repos = [repo for repo in (scan_repo(d) for d in sorted(git_dirs)) if repo]
+    return sorted(repos, key=lambda r: r.name.lower())
+
+
+# -- size --------------------------------------------------------------------
+
+_sizes: dict[str, tuple[float, int]] = {}
+
+
+def size_bytes(path: str) -> int | None:
+    """Disk usage of a worktree, cached until its top level changes. Slow with node_modules, so
+    only computed on request."""
+    touched = _last_touched(path)
+    cached = _sizes.get(path)
+    if cached and cached[0] == touched:
+        return cached[1]
+    try:
+        out = subprocess.run(["du", "-sk", path], capture_output=True, text=True, timeout=120).stdout
+        size = int(out.split()[0]) * 1024
+    except (subprocess.TimeoutExpired, ValueError, IndexError, OSError):
+        return None
+    _sizes[path] = (touched, size)
+    return size
+
+
+# -- removing ----------------------------------------------------------------
+
+def _is_inside(path: str, folder: str) -> bool:
+    return path == folder or path.startswith(folder.rstrip("/") + "/")
+
+
+def remove(path: str, delete_branch: bool, busy_cwds: list[str]) -> dict:
+    """`git worktree remove`, which refuses worktrees with changes, then `git branch -d` (never -D)
+    when asked and the branch is merged, then `git worktree prune`.
+
+    Refuses the main worktree and worktrees something is running in (`busy_cwds`).
+    """
+    path = os.path.realpath(path)
+    git_dir = common_dir(path)
+    if git_dir is None:
+        raise ValueError(f"{path} is not in a git repository")
+    repo = scan_repo(git_dir)
+    wt = next((w for w in (repo.worktrees if repo else []) if os.path.realpath(w.path) == path), None)
+    if repo is None or wt is None:
+        raise ValueError(f"{path} is not a linked worktree")
+    if wt.is_main:
+        raise ValueError("The main checkout can't be removed")
+    for cwd in busy_cwds:
+        if cwd and _is_inside(os.path.realpath(cwd), path):
+            raise ValueError("Something is still running in this worktree. Stop it first.")
+    if wt.changes:
+        raise ValueError(f"The worktree has {wt.changes} uncommitted change{'s' if wt.changes != 1 else ''}")
+
+    if not wt.prunable:
+        _git(repo.root, "worktree", "remove", path)
+    _git(repo.root, "worktree", "prune")
+    _common_dirs.pop(path, None)
+
+    branch_deleted = False
+    note = ""
+    if delete_branch and wt.branch:
+        try:
+            _git(repo.root, "branch", "-d", wt.branch)
+            branch_deleted = True
+        except RuntimeError as e:
+            # -d refuses branches that aren't merged into HEAD; squash merges land here.
+            message = re.sub(r"^error: ", "", str(e)).splitlines()[0]
+            note = "not fully merged" if "not fully merged" in message else message
+    return {"path": path, "branch": wt.branch, "branch_deleted": branch_deleted, "note": note}
diff --git a/macos/Sources/DevDashBar/DevDashBarApp.swift b/macos/Sources/DevDashBar/DevDashBarApp.swift
index 91f9087..611b20e 100644
--- a/macos/Sources/DevDashBar/DevDashBarApp.swift
+++ b/macos/Sources/DevDashBar/DevDashBarApp.swift
@@ -49,6 +49,7 @@ struct DevDashBarApp: App {
         WindowGroup("Logs", id: "logs", for: LogTarget.self) { $target in
             if let target {
                 LogsView(target: target)
+                    .environment(store)
             }
         }
         .defaultSize(width: 760, height: 480)
diff --git a/macos/Sources/DevDashBar/Models.swift b/macos/Sources/DevDashBar/Models.swift
index 6f81bb3..bf77d60 100644
--- a/macos/Sources/DevDashBar/Models.swift
+++ b/macos/Sources/DevDashBar/Models.swift
@@ -75,9 +75,23 @@ struct Server: Decodable, Sendable, Identifiable, Hashable {
     let projectRoot: String
     let projectName: String
     let package: String
+    /// Nil from a devdash CLI older than 0.5.
+    let urls: [ServerURL]?
+    let exposeHint: String?
+    /// The managed run this process belongs to, when devdash started it. Nil from a CLI older than 0.7.
+    let runId: String?
 
     var id: Int { pid }
+    var isManaged: Bool { runId != nil }
     var isBackground: Bool { kind == "background" }
+    var isApp: Bool { kind == "app" }
+
+    func url(for port: Int) -> ServerURL {
+        urls?.first { $0.port == port } ?? ServerURL(port: port, local: "http://localhost:\(port)", lan: nil, exposed: false)
+    }
+
+    /// The URL for the first port, which is the app itself for most dev servers.
+    var primaryURL: ServerURL? { ports.first.map(url(for:)) }
     var isService: Bool { kind == "service" }
     var displayName: String { label.isEmpty ? name : label }
     /// The command with paths shortened: relative to the working directory, `~` for home, and the
@@ -103,11 +117,131 @@ extension Server {
             pid: node.pid, name: node.name, label: node.displayName, runtime: "node",
             kind: node.ports.isEmpty ? "background" : "app", command: node.command,
             cpuPercent: node.cpuPercent, memoryMb: node.memoryMb, ports: node.ports, uptime: node.uptime,
-            started: 0, cwd: node.cwd, cwdFull: node.cwdFull, projectRoot: "", projectName: node.project, package: ""
+            started: 0, cwd: node.cwd, cwdFull: node.cwdFull, projectRoot: "", projectName: node.project, package: "",
+            urls: nil, exposeHint: nil, runId: nil
         )
     }
 }
 
+/// A port's address on this Mac, and on the local network when other devices can reach it.
+struct ServerURL: Decodable, Sendable, Hashable {
+    let port: Int
+    let local: String
+    /// Nil when the port listens on loopback only, or the Mac isn't on a network.
+    let lan: String?
+    /// Whether the port listens beyond loopback.
+    let exposed: Bool
+}
+
+/// A dev server devdash started (devdash/supervisor.py).
+struct ManagedRun: Decodable, Sendable, Hashable, Identifiable {
+    let id: String
+    let projectRoot: String
+    let projectName: String
+    let scriptId: String
+    let name: String
+    let command: String
+    let cwd: String
+    let package: String
+    let log: String
+    /// Also the process group, which every process the script starts belongs to.
+    let pid: Int
+    let started: Double
+    /// "running", "restarting" (waiting to restart after a crash), "exited" or "crashed".
+    let status: String
+    let exitCode: Int?
+    let ended: Double
+    let restartOnCrash: Bool
+    let restarts: [Double]
+    /// Crashed too often in a row, so restart on crash stopped.
+    let gaveUp: Bool
+    let ports: [Int]
+
+    var isAlive: Bool { status == "running" || status == "restarting" }
+    var isCrashed: Bool { status == "crashed" }
+    /// "dev" or "web dev" for a script of a workspace package.
+    var title: String { package.isEmpty ? name : "\(package) \(name)" }
+    var startDate: Date { Date(timeIntervalSince1970: started) }
+    var endDate: Date { Date(timeIntervalSince1970: ended) }
+}
+
+/// Something a project can run: a package.json script or a Procfile entry (devdash/runnable.py).
+struct RunScript: Decodable, Sendable, Hashable, Identifiable {
+    let id: String
+    let name: String
+    let command: String
+    let source: String
+    let cwd: String
+    let package: String
+
+    var title: String { package.isEmpty ? name : "\(package) \(name)" }
+}
+
+struct RunnableProject: Decodable, Sendable, Hashable, Identifiable {
+    let root: String
+    let name: String
+    let scripts: [RunScript]
+    /// What "Run" starts: the script run last time, else the first.
+    let `default`: String?
+    /// A recent Claude project with nothing on screen, offered under "Ready to run".
+    let recent: Bool
+
+    var id: String { root }
+    var defaultScript: RunScript? { scripts.first { $0.id == `default` } ?? scripts.first }
+}
+
+struct PortConflict: Decodable, Sendable, Hashable {
+    let port: Int
+    let pid: Int
+    let label: String
+    let project: String
+}
+
+struct RunResult: Decodable, Sendable {
+    let run: ManagedRun?
+    let conflict: PortConflict?
+}
+
+/// A repository with linked worktrees (devdash/worktrees.py).
+struct WorktreeRepo: Decodable, Sendable, Hashable, Identifiable {
+    let root: String
+    let name: String
+    let defaultBranch: String
+    let worktrees: [Worktree]
+
+    var id: String { root }
+}
+
+struct Worktree: Decodable, Sendable, Hashable, Identifiable {
+    let path: String
+    let branch: String
+    let head: String
+    let isMain: Bool
+    let locked: Bool
+    let prunable: Bool
+    let changes: Int
+    let merged: Bool
+    let upstreamGone: Bool
+    let lastCommit: Double
+    let subject: String
+    let lastTouched: Double
+    let createdBy: String
+    /// "missing", "changes", "merged", "stale" or "active". Store.status(of:) adds "running".
+    let status: String
+
+    var id: String { path }
+    var displayBranch: String { branch.isEmpty ? "detached at \(head)" : branch }
+    var folder: String { (path as NSString).lastPathComponent }
+    var lastActivity: Date { Date(timeIntervalSince1970: max(lastTouched, lastCommit)) }
+}
+
+struct RemoveWorktreeResult: Decodable, Sendable {
+    let path: String
+    let branch: String
+    let branchDeleted: Bool
+    let note: String
+}
+
 /// Name and git branch of a project root that appears in the snapshot.
 struct ProjectInfo: Decodable, Sendable, Hashable {
     let root: String
@@ -281,7 +415,13 @@ struct Snapshot: Decodable, Sendable {
     let system: SystemStats
     let node: [NodeProcess]
     let servers: [Server]?
+    /// Dev servers devdash started, nil from a CLI older than 0.7.
+    let runs: [ManagedRun]?
+    /// Only sent when it changed.
+    let runnable: [RunnableProject]?
     let projects: [ProjectInfo]?
+    /// Only sent when the worktree scan changed, about once a minute at most.
+    let worktrees: [WorktreeRepo]?
     let docker: [DockerContainer]
     let processes: [GeneralProcess]
     let cleanup: [CleanupSuggestion]
diff --git a/macos/Sources/DevDashBar/SelfTest.swift b/macos/Sources/DevDashBar/SelfTest.swift
index 2b4a2f2..bf18384 100644
--- a/macos/Sources/DevDashBar/SelfTest.swift
+++ b/macos/Sources/DevDashBar/SelfTest.swift
@@ -46,6 +46,7 @@ enum SelfTest {
             print("FAIL no snapshot received")
             return 1
         }
+        print("ok   runs=\(snapshot.runs?.count ?? -1) runnable=\(snapshot.runnable?.count ?? -1)")
         print("ok   snapshot node=\(snapshot.node.count) docker=\(snapshot.docker.count) procs=\(snapshot.processes.count) cleanup=\(snapshot.cleanup.count) claude=\(claudeSeen)")
 
         var failures = 0
@@ -174,6 +175,14 @@ enum Renderer {
             .forEach(store.toggleCollapsed)
     }
 
+    /// The QR page of the first app server that matches.
+    @MainActor
+    private static func urlRoute(_ store: Store, where match: (Server) -> Bool) -> [Route] {
+        guard let server = store.servers.first(where: { $0.isApp && match($0) }),
+              let port = server.ports.first else { return [] }
+        return [.serverURL(pid: server.pid, port: port)]
+    }
+
     @MainActor
     private static func render(to dir: URL) async {
         try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
@@ -196,15 +205,52 @@ enum Renderer {
             ("project", { store.routes = store.claude?.projects.first.map { [.claudeProject(path: $0.path)] } ?? [] }),
             ("detail", { store.routes = store.servers.first.map { [.processDetail(pid: $0.pid, name: $0.displayName)] } ?? [] }),
             ("settings", { store.routes = [.settings] }),
+            ("qrcode", { store.routes = urlRoute(store) { $0.primaryURL?.lan != nil } }),
+            ("worktrees", { store.routes = [.worktrees(repo: nil, cleanup: false)] }),
+            ("qrcode-localhost", { store.routes = urlRoute(store) { $0.exposeHint?.hasPrefix("Restart") == true } }),
+            // A crashed run without a server row, in its project.
+            ("run-crashed", {
+                store.routes = []
+                toggleProjects(store)
+                if let run = store.crashedRuns.first { store.toggleCollapsed(id: run.projectRoot) }
+            }),
         ]
         for (name, apply) in screens {
             apply()
             try? await Task.sleep(for: .milliseconds(1500))
             capture(panel, to: dir.appendingPathComponent("\(name).png"))
         }
+        toggleProjects(store)
+        if let run = store.crashedRuns.first { store.toggleCollapsed(id: run.projectRoot) }
         store.routes = []
         store.tab = .running
 
+        // Ready to run sits at the bottom, so this one gets its own store with Needs you dismissed.
+        let readyStore = Store()
+        await waitForData(readyStore)
+        toggleProjects(readyStore)
+        readyStore.toggleCollapsed(id: ReadyToRunSection.id)
+        Attention.items(store: readyStore, disk: disk).forEach(readyStore.dismiss)
+        let readyPanel = host(PanelFrame { PopoverView().environment(readyStore).environment(disk) }, size: PanelFrame<EmptyView>.size)
+        try? await Task.sleep(for: .milliseconds(1500))
+        capture(readyPanel, to: dir.appendingPathComponent("ready.png"))
+        readyStore.shutdown()
+
+        // Running admin's dev server, whose port another project's server holds (demo data).
+        if let admin = store.readyToRun.first(where: { $0.name == "admin" }), let script = admin.defaultScript {
+            store.run(script, in: admin)
+            try? await Task.sleep(for: .milliseconds(3500))  // after the toast
+            capture(panel, to: dir.appendingPathComponent("port-conflict.png"))
+            store.dismissPortConflict()
+        }
+
+        if let run = store.runs.first(where: \.isAlive) {
+            let target = LogTarget(file: run.log, runId: run.id, name: "\(run.title) · \(run.projectName)")
+            let logs = host(LogsView(target: target).environment(store).background(.background), size: CGSize(width: 760, height: 420))
+            try? await Task.sleep(for: .milliseconds(1500))
+            capture(logs, to: dir.appendingPathComponent("logs.png"))
+        }
+
         let claudeStore = Store()
         let usageStore = Store()
         await waitForData(claudeStore)
diff --git a/macos/Sources/DevDashBar/Store.swift b/macos/Sources/DevDashBar/Store.swift
index 624e26e..117d6ed 100644
--- a/macos/Sources/DevDashBar/Store.swift
+++ b/macos/Sources/DevDashBar/Store.swift
@@ -39,6 +39,9 @@ enum Grouping: String, CaseIterable, Identifiable {
 
 enum Route: Hashable {
     case processDetail(pid: Int, name: String)
+    case serverURL(pid: Int, port: Int)
+    /// All repositories, or one; `cleanup` shows only merged worktrees nothing runs in.
+    case worktrees(repo: String?, cleanup: Bool)
     case claudeProject(path: String)
     case cleanup
     case graph
@@ -48,6 +51,15 @@ enum Route: Hashable {
     case whatsNew
 }
 
+/// A run that didn't start because a process devdash didn't start holds its port.
+struct PendingConflict: Equatable {
+    let conflict: PortConflict
+    let root: String
+    let scriptId: String
+    let title: String
+    let projectName: String
+}
+
 struct Toast: Identifiable, Equatable {
     let id = UUID()
     let message: String
@@ -74,6 +86,12 @@ final class Store {
     private(set) var system: SystemStats?
     private(set) var node: [NodeProcess] = []
     private(set) var servers: [Server] = []
+    private(set) var runs: [ManagedRun] = []
+    /// What each project can run, by project root.
+    private(set) var runnable: [String: RunnableProject] = [:]
+    private(set) var portConflict: PendingConflict?
+    private(set) var worktreeRepos: [WorktreeRepo] = []
+    private(set) var worktreeSizes: [String: Int64] = [:]
     private(set) var projects: [String: ProjectInfo] = [:]
     private(set) var docker: [DockerContainer] = []
     private(set) var processes: [GeneralProcess] = []
@@ -200,6 +218,11 @@ final class Store {
         system = snapshot.system
         node = snapshot.node
         servers = snapshot.servers ?? snapshot.node.map(Server.init(node:))
+        if let worktrees = snapshot.worktrees { worktreeRepos = worktrees }
+        runs = snapshot.runs ?? []
+        if let runnable = snapshot.runnable {
+            self.runnable = Dictionary(runnable.map { ($0.root, $0) }, uniquingKeysWith: { a, _ in a })
+        }
         projects = Dictionary((snapshot.projects ?? []).map { ($0.root, $0) }, uniquingKeysWith: { a, _ in a })
         docker = snapshot.docker
         processes = snapshot.processes
@@ -215,7 +238,7 @@ final class Store {
         cpuHistory.append(snapshot.system.cpuPercent)
         if cpuHistory.count > 40 { cpuHistory.removeFirst(cpuHistory.count - 40) }
 
-        let events = tracker.diff(servers: servers, docker: snapshot.docker, watchedPorts: config.watchedPorts)
+        let events = tracker.diff(servers: servers, docker: snapshot.docker, runs: runs, watchedPorts: config.watchedPorts)
         if UserDefaults.standard.object(forKey: SettingsKey.notifications) as? Bool ?? true {
             Notifier.post(events)
         }
@@ -324,7 +347,9 @@ final class Store {
     /// Kills every server and stops every container of a Running group.
     func stopGroup(_ group: RunningGroup) {
         let key = "group-\(group.id)"
-        let targets = group.servers.filter { !$0.isBackground }
+        // Servers devdash started stop with their whole run, which also ends the script that started them.
+        let runIds = Set(group.servers.compactMap(\.runId) + group.runs.filter(\.isAlive).map(\.id))
+        let targets = group.servers.filter { !$0.isBackground && $0.runId == nil }
         pending.insert(key)
         targets.forEach { pending.insert("pid-\($0.pid)") }
         group.containers.forEach { pending.insert("ctr-\($0.containerId)") }
@@ -334,12 +359,17 @@ final class Store {
                 targets.forEach { pending.remove("pid-\($0.pid)") }
                 group.containers.forEach { pending.remove("ctr-\($0.containerId)") }
             }
+            var stoppedRuns = 0
+            for id in runIds where (try? await bridge.send("stop_run", ["run": id])) != nil { stoppedRuns += 1 }
             let items: [[String: Any]] = targets.map { ["action_type": "kill", "pid": $0.pid] }
                 + group.containers.map { ["action_type": "stop_container", "container_id": $0.containerId] }
             do {
-                let result = try await bridge.request("cleanup", ["items": items], as: CleanupResult.self)
-                let done = result.killed + result.stopped
-                showToast("Stopped \(done) of \(items.count) in \(group.name)", isError: result.failed > 0)
+                let result = items.isEmpty
+                    ? CleanupResult(killed: 0, stopped: 0, failed: 0)
+                    : try await bridge.request("cleanup", ["items": items], as: CleanupResult.self)
+                let done = result.killed + result.stopped + stoppedRuns
+                let total = items.count + runIds.count
+                showToast("Stopped \(done) of \(total) in \(group.name)", isError: result.failed > 0 || stoppedRuns < runIds.count)
             } catch {
                 showToast(error.localizedDescription, isError: true)
             }
@@ -377,6 +407,202 @@ final class Store {
         }
     }
 
+    // MARK: Running scripts
+
+    /// Whether the bridge can start scripts (a devdash CLI from 0.7 on).
+    var canRun: Bool { !runnable.isEmpty }
+
+    func run(id: String) -> ManagedRun? { runs.first { $0.id == id } }
+
+    /// The run a script has, while it's running or waiting to restart.
+    func liveRun(root: String, scriptId: String) -> ManagedRun? {
+        runs.first { $0.projectRoot == root && $0.scriptId == scriptId && $0.isAlive }
+    }
+
+    /// Runs without a server row of their own: still starting, without a port (a worker), or ended.
+    func runsWithoutServers() -> [ManagedRun] {
+        let shown = Set(servers.compactMap(\.runId))
+        return runs.filter { !shown.contains($0.id) }
+    }
+
+    var crashedRuns: [ManagedRun] { runs.filter(\.isCrashed) }
+
+    /// Projects that can run something and have nothing on screen: the recent Claude projects.
+    var readyToRun: [RunnableProject] {
+        var busy = Set(servers.map(\.projectRoot))
+        busy.formUnion(docker.compactMap(\.projectRoot))
+        busy.formUnion(claudeInstances.compactMap(\.projectRoot))
+        busy.formUnion(runs.map(\.projectRoot))
+        return runnable.values
+            .filter { !busy.contains($0.root) && !$0.scripts.isEmpty }
+            .sorted { $0.name.localizedCaseInsensitiveCompare($1.name) == .orderedAscending }
+    }
+
+    /// Starts a script. With `stopping`, first stops the process that holds its port.
+    func run(_ script: RunScript, in project: RunnableProject, stopping pid: Int? = nil) {
+        start(root: project.root, scriptId: script.id, title: script.title, projectName: project.name, stopping: pid)
+    }
+
+    private func start(root: String, scriptId: String, title: String, projectName: String, stopping pid: Int? = nil) {
+        let key = "run-\(root)#\(scriptId)"
+        guard !pending.contains(key) else { return }
+        pending.insert(key)
+        Task {
+            defer { pending.remove(key) }
+            var args: [String: Any] = ["root": root, "script": scriptId]
+            if let pid { args["stop_pid"] = pid }
+            do {
+                let result = try await bridge.request("run_script", args, as: RunResult.self)
+                handle(result, root: root, scriptId: scriptId, title: title, projectName: projectName, verb: "Started")
+            } catch {
+                showToast(error.localizedDescription, isError: true)
+            }
+        }
+    }
+
+    private func handle(_ result: RunResult, root: String, scriptId: String, title: String, projectName: String, verb: String) {
+        if let conflict = result.conflict {
+            portConflict = PendingConflict(conflict: conflict, root: root, scriptId: scriptId, title: title, projectName: projectName)
+            showToast("Port \(conflict.port) is in use by \(conflict.label)", isError: true)
+        } else if let run = result.run {
+            if portConflict?.root == root && portConflict?.scriptId == scriptId { portConflict = nil }
+            runs.removeAll { $0.id == run.id }
+            runs.append(run)
+            showToast("\(verb) \(title) in \(projectName)")
+        }
+    }
+
+    /// Stops the process holding the port, then starts the run that wanted it.
+    func resolvePortConflict() {
+        guard let pending = portConflict else { return }
+        portConflict = nil
+        start(root: pending.root, scriptId: pending.scriptId, title: pending.title, projectName: pending.projectName,
+              stopping: pending.conflict.pid)
+    }
+
+    func dismissPortConflict() { portConflict = nil }
+
+    func stopRun(_ run: ManagedRun) {
+        let key = "run-\(run.id)"
+        pending.insert(key)
+        Task {
+            defer { pending.remove(key) }
+            do {
+                try await bridge.send("stop_run", ["run": run.id])
+                runs.removeAll { $0.id == run.id }
+                showToast("Stopped \(run.title) in \(run.projectName)")
+            } catch {
+                showToast(error.localizedDescription, isError: true)
+            }
+        }
+    }
+
+    func restartRun(_ run: ManagedRun) {
+        let key = "run-\(run.id)"
+        guard !pending.contains(key) else { return }
+        pending.insert(key)
+        Task {
+            defer { pending.remove(key) }
+            do {
+                let result = try await bridge.request("restart_run", ["run": run.id], as: RunResult.self)
+                handle(result, root: run.projectRoot, scriptId: run.scriptId, title: run.title, projectName: run.projectName,
+                       verb: run.isAlive ? "Restarted" : "Started")
+            } catch {
+                showToast(error.localizedDescription, isError: true)
+            }
+        }
+    }
+
+    /// Removes an ended run from the list.
+    func clearRun(_ run: ManagedRun) {
+        runs.removeAll { $0.id == run.id }
+        Task { try? await bridge.send("clear_run", ["run": run.id]) }
+    }
+
+    func setRestartOnCrash(_ run: ManagedRun, _ on: Bool) {
+        Task {
+            do {
+                let updated = try await bridge.request("restart_on_crash", ["run": run.id, "on": on], as: ManagedRun.self)
+                if let index = runs.firstIndex(where: { $0.id == updated.id }) { runs[index] = updated }
+                showToast(on ? "\(run.title) restarts when it crashes" : "\(run.title) stays down when it crashes")
+            } catch {
+                showToast(error.localizedDescription, isError: true)
+            }
+        }
+    }
+
+    // MARK: Worktrees
+
+    /// The worktree a folder is in: the deepest match, since agent worktrees often live inside the
+    /// main checkout (`<repo>/.claude/worktrees/...`).
+    func worktree(containing path: String) -> Worktree? {
+        worktreeRepos.lazy.flatMap(\.worktrees)
+            .filter { path == $0.path || path.hasPrefix($0.path + "/") }
+            .max { $0.path.count < $1.path.count }
+    }
+
+    func repo(of worktree: Worktree) -> WorktreeRepo? {
+        worktreeRepos.first { $0.worktrees.contains(worktree) }
+    }
+
+    /// The repository a project root belongs to, when it has linked worktrees.
+    func worktreeRepo(containing root: String) -> WorktreeRepo? {
+        worktreeRepos.first { $0.worktrees.contains { $0.path == root } }
+    }
+
+    /// Dev servers and Claude sessions running inside a worktree.
+    func activity(in worktree: Worktree) -> (servers: [Server], sessions: [ClaudeInstance]) {
+        (servers.filter { self.worktree(containing: $0.cwdFull)?.path == worktree.path },
+         claudeInstances.filter { self.worktree(containing: $0.cwdFull)?.path == worktree.path })
+    }
+
+    func status(of worktree: Worktree) -> String {
+        let activity = activity(in: worktree)
+        return activity.servers.isEmpty && activity.sessions.isEmpty ? worktree.status : "running"
+    }
+
+    /// Merged worktrees with nothing running and no edits for a day: safe to remove.
+    var idleMergedWorktrees: [Worktree] {
+        let dayAgo = Date().addingTimeInterval(-86_400)
+        return worktreeRepos.flatMap(\.worktrees).filter { status(of: $0) == "merged" && $0.lastActivity < dayAgo }
+    }
+
+    func refreshWorktrees() {
+        Task { try? await bridge.send("refresh_worktrees") }
+    }
+
+    /// Sizes one at a time, since `du` over node_modules is slow and the bridge has few workers.
+    func loadSizes(for worktrees: [Worktree]) async {
+        for worktree in worktrees where !worktree.prunable && worktreeSizes[worktree.path] == nil {
+            // try? flattens the optional result, so null (du failed) and errors both skip.
+            guard let size = try? await bridge.request("worktree_size", ["path": worktree.path], as: Int64?.self) else { continue }
+            worktreeSizes[worktree.path] = size
+        }
+    }
+
+    func remove(_ worktree: Worktree, deleteBranch: Bool) {
+        let key = "wt-\(worktree.path)"
+        pending.insert(key)
+        Task {
+            defer { pending.remove(key) }
+            do {
+                let result = try await bridge.request(
+                    "remove_worktree", ["path": worktree.path, "delete_branch": deleteBranch], as: RemoveWorktreeResult.self
+                )
+                worktreeSizes[worktree.path] = nil
+                if result.branchDeleted {
+                    showToast("Removed \(worktree.folder) and branch \(result.branch)")
+                } else if deleteBranch, !result.note.isEmpty {
+                    showToast("Removed \(worktree.folder), kept branch \(result.branch) (\(result.note))")
+                } else {
+                    showToast("Removed \(worktree.folder)")
+                }
+            } catch {
+                showToast(error.localizedDescription, isError: true)
+            }
+        }
+    }
+
     func processDetail(pid: Int) async throws -> ProcessDetail {
         try await bridge.request("process_detail", ["pid": pid], as: ProcessDetail.self)
     }
@@ -405,11 +631,17 @@ final class Store {
     func focusSearch() { searchFocusRequest += 1 }
 
     func isCollapsed(_ group: RunningGroup) -> Bool {
-        toggledGroups.contains(group.id) ? !group.collapsedByDefault : group.collapsedByDefault
+        isCollapsed(id: group.id, byDefault: group.collapsedByDefault)
+    }
+
+    func isCollapsed(id: String, byDefault: Bool) -> Bool {
+        toggledGroups.contains(id) ? !byDefault : byDefault
     }
 
-    func toggleCollapsed(_ group: RunningGroup) {
-        if toggledGroups.contains(group.id) { toggledGroups.remove(group.id) } else { toggledGroups.insert(group.id) }
+    func toggleCollapsed(_ group: RunningGroup) { toggleCollapsed(id: group.id) }
+
+    func toggleCollapsed(id: String) {
+        if toggledGroups.contains(id) { toggledGroups.remove(id) } else { toggledGroups.insert(id) }
     }
 
     /// The welcome tour on a fresh install, or release notes for versions not seen yet.
@@ -459,19 +691,31 @@ struct ChangeTracker {
     private var initialized = false
     private var serverPorts: [Int: (name: String, ports: [Int])] = [:]
     private var containers: [String: String] = [:]
+    private var runStatuses: [String: String] = [:]
 
-    mutating func diff(servers: [Server], docker: [DockerContainer], watchedPorts: [Int]) -> [String] {
-        let apps = servers.filter { $0.kind == "app" }
+    mutating func diff(servers: [Server], docker: [DockerContainer], runs: [ManagedRun], watchedPorts: [Int]) -> [String] {
+        // Servers devdash started come and go on Run, Stop and Restart; their crashes are reported below.
+        let apps = servers.filter { $0.kind == "app" && !$0.isManaged }
         let currentPorts = Dictionary(apps.map { ($0.pid, (name: $0.reportName, ports: $0.ports)) }, uniquingKeysWith: { a, _ in a })
         let currentContainers = Dictionary(docker.map { ($0.containerId, $0.displayName) }, uniquingKeysWith: { a, _ in a })
+        let currentRuns = Dictionary(runs.map { ($0.id, $0.status) }, uniquingKeysWith: { a, _ in a })
         defer {
             serverPorts = currentPorts
             containers = currentContainers
+            runStatuses = currentRuns
             initialized = true
         }
         guard initialized else { return [] }
 
         var events: [String] = []
+        for run in runs where runStatuses[run.id] == "running" && run.status != "running" {
+            switch run.status {
+            case "restarting": events.append("\(run.title) crashed in \(run.projectName), restarting")
+            case "crashed" where run.gaveUp: events.append("\(run.title) in \(run.projectName) keeps crashing, stopped restarting it")
+            case "crashed": events.append("\(run.title) crashed in \(run.projectName) (exit code \(run.exitCode.map(String.init) ?? "?"))")
+            default: break
+            }
+        }
         for (pid, previous) in serverPorts where currentPorts[pid] == nil && !previous.ports.isEmpty {
             events.append("\(previous.name) on \(portList(previous.ports)) exited")
         }
diff --git a/macos/Sources/DevDashBar/Views/AttentionView.swift b/macos/Sources/DevDashBar/Views/AttentionView.swift
index 227f56b..1f94663 100644
--- a/macos/Sources/DevDashBar/Views/AttentionView.swift
+++ b/macos/Sources/DevDashBar/Views/AttentionView.swift
@@ -8,7 +8,7 @@ struct AttentionItem: Identifiable, Equatable {
         static func < (lhs: Severity, rhs: Severity) -> Bool { lhs.rawValue < rhs.rawValue }
     }
 
-    enum Action { case retry, cleanup, disk, usage, whatsNew }
+    enum Action: Equatable { case retry, cleanup, disk, usage, whatsNew, worktrees, runLogs(String), stopAndRun }
 
     let id: String
     let severity: Severity
@@ -63,6 +63,30 @@ enum Attention {
             ))
         }
 
+        if let pending = store.portConflict {
+            let conflict = pending.conflict
+            let holder = conflict.project.isEmpty ? conflict.label : "\(conflict.label) in \(conflict.project)"
+            items.append(AttentionItem(
+                id: "conflict", severity: .warning, symbol: "exclamationmark.octagon",
+                title: "\(pending.title) in \(pending.projectName) can't use port \(conflict.port)",
+                detail: "\(holder) holds it, PID \(conflict.pid)",
+                actionTitle: "Stop and run", action: .stopAndRun
+            ))
+        }
+
+        for run in store.crashedRuns {
+            let code = run.exitCode.map { "Exit code \($0)" } ?? "Crashed"
+            items.append(AttentionItem(
+                id: "crash-\(run.id)", severity: .warning, symbol: "exclamationmark.triangle",
+                title: "\(run.title) crashed in \(run.projectName)",
+                detail: run.gaveUp
+                    ? "Crashed 3 times in 5 minutes, stopped restarting it"
+                    : "\(code), \(run.endDate.formatted(.relative(presentation: .named)))",
+                actionTitle: "Logs", action: .runLogs(run.id),
+                signature: String(run.ended)
+            ))
+        }
+
         if let limit = store.usage?.limits.filter({ $0.percent >= limitThreshold }).max(by: { $0.percent < $1.percent }) {
             let percent = Int(limit.percent.rounded())
             var detail = "\(limit.label) limit"
@@ -86,6 +110,18 @@ enum Attention {
             ))
         }
 
+        let merged = store.idleMergedWorktrees
+        if !merged.isEmpty {
+            let repos = Set(merged.compactMap { store.repo(of: $0)?.name }).sorted()
+            items.append(AttentionItem(
+                id: "worktrees", severity: .info, symbol: "arrow.triangle.branch",
+                title: "\(merged.count) merged worktree\(merged.count == 1 ? "" : "s") to clean up",
+                detail: "In " + ListFormatter.localizedString(byJoining: Array(repos.prefix(3))),
+                actionTitle: "Review", action: .worktrees,
+                signature: merged.map(\.path).sorted().joined(separator: ",")
+            ))
+        }
+
         if let note = store.whatsNew {
             let title = note.welcome ? "Welcome to devdash" : "What's new in \(note.releases.first?.version ?? "")"
             let detail = note.welcome
@@ -159,6 +195,10 @@ struct AttentionSection: View {
         case .cleanup: store.push(.cleanup)
         case .usage: store.push(.usage)
         case .whatsNew: store.push(.whatsNew)
+        case .worktrees: store.push(.worktrees(repo: nil, cleanup: true))
+        case .stopAndRun: store.resolvePortConflict()
+        case .runLogs(let id):
+            if let run = store.run(id: id) { openLogs(run, openWindow) }
         case .disk:
             openWindow(id: "disk")
             NSApp.activate(ignoringOtherApps: true)
@@ -167,7 +207,11 @@ struct AttentionSection: View {
 
     private func dismiss(_ item: AttentionItem) {
         withAnimation(.snappy(duration: 0.22)) {
-            if item.action == .whatsNew { store.markWhatsNewSeen() } else { store.dismiss(item) }
+            switch item.action {
+            case .whatsNew: store.markWhatsNewSeen()
+            case .stopAndRun: store.dismissPortConflict()
+            default: store.dismiss(item)
+            }
         }
     }
 }
diff --git a/macos/Sources/DevDashBar/Views/Components.swift b/macos/Sources/DevDashBar/Views/Components.swift
index 11ebb6e..8d08d0e 100644
--- a/macos/Sources/DevDashBar/Views/Components.swift
+++ b/macos/Sources/DevDashBar/Views/Components.swift
@@ -138,12 +138,22 @@ struct Sparkline: View {
 // MARK: - Chips and badges
 
 struct PortChip: View {
+    @Environment(Store.self) private var store
     let port: Int
+    /// What a click opens; defaults to http://localhost:PORT.
+    var url: String?
     var interactive = true
 
+    private var target: String { url ?? "http://localhost:\(port)" }
+
     var body: some View {
         Button {
-            Launcher.openPort(port)
+            if NSEvent.modifierFlags.contains(.option) {
+                Pasteboard.copy(target)
+                store.showToast("Copied \(target)")
+            } else {
+                Launcher.openURL(target)
+            }
         } label: {
             Text(verbatim: ":\(port)")
                 .font(.system(size: 10.5, weight: .semibold, design: .monospaced))
@@ -154,7 +164,7 @@ struct PortChip: View {
         }
         .buttonStyle(.plain)
         .disabled(!interactive)
-        .help("Open http://localhost:\(port)")
+        .help("Open \(target). Option-click to copy.")
     }
 }
 
diff --git a/macos/Sources/DevDashBar/Views/DevTabs.swift b/macos/Sources/DevDashBar/Views/DevTabs.swift
index 76122d9..cf27745 100644
--- a/macos/Sources/DevDashBar/Views/DevTabs.swift
+++ b/macos/Sources/DevDashBar/Views/DevTabs.swift
@@ -2,8 +2,11 @@ import SwiftUI
 
 // MARK: - Docker
 
+/// A container's logs, or the log file of a run devdash started.
 struct LogTarget: Codable, Hashable {
-    let containerId: String
+    var containerId: String?
+    var file: String?
+    var runId: String?
     let name: String
 }
 
diff --git a/macos/Sources/DevDashBar/Views/LogsView.swift b/macos/Sources/DevDashBar/Views/LogsView.swift
index b21d2b2..8aa0113 100644
--- a/macos/Sources/DevDashBar/Views/LogsView.swift
+++ b/macos/Sources/DevDashBar/Views/LogsView.swift
@@ -1,7 +1,7 @@
 import AppKit
 import SwiftUI
 
-/// Streams `docker logs --follow` for one container.
+/// Streams `docker logs --follow` for a container, or `tail -F` for the log file of a run.
 @MainActor
 @Observable
 final class LogStream {
@@ -17,15 +17,20 @@ final class LogStream {
     @ObservationIgnored private var counter = 0
     private let maxLines = 5000
 
-    func start(containerId: String) {
+    func start(_ target: LogTarget) {
         stop()
-        guard let docker = ShellEnvironment.which("docker") else {
+        let process = Process()
+        if let file = target.file {
+            // -F keeps following when the log is truncated or replaced.
+            process.executableURL = URL(fileURLWithPath: "/usr/bin/tail")
+            process.arguments = ["-n", "300", "-F", file]
+        } else if let containerId = target.containerId, let docker = ShellEnvironment.which("docker") {
+            process.executableURL = docker
+            process.arguments = ["logs", "--tail", "300", "--follow", containerId]
+        } else {
             failure = "docker CLI not found"
             return
         }
-        let process = Process()
-        process.executableURL = docker
-        process.arguments = ["logs", "--tail", "300", "--follow", containerId]
         process.environment = ShellEnvironment.childEnvironment()
         let pipe = Pipe()
         process.standardOutput = pipe
@@ -63,10 +68,17 @@ final class LogStream {
 
     func clear() { lines.removeAll() }
 
+    /// Without terminal color codes and carriage-return redraws.
+    static func plain(_ text: String) -> String {
+        var text = text.replacing(#/\x1B\[[0-9;?]*[A-Za-z]/#, with: "")
+        if let last = text.split(separator: "\r", omittingEmptySubsequences: true).last { text = String(last) }
+        return text
+    }
+
     private func append(_ newLines: [String]) {
         for text in newLines {
             counter += 1
-            lines.append(Line(id: counter, text: text))
+            lines.append(Line(id: counter, text: Self.plain(text)))
         }
         if lines.count > maxLines { lines.removeFirst(lines.count - maxLines) }
     }
@@ -87,6 +99,7 @@ private final class LogBuffer: @unchecked Sendable {
 }
 
 struct LogsView: View {
+    @Environment(Store.self) private var store
     let target: LogTarget
     @State private var stream = LogStream()
     @State private var filter = ""
@@ -97,9 +110,13 @@ struct LogsView: View {
             HStack(spacing: 8) {
                 StatusDot(color: stream.isRunning ? .green : .secondary, pulsing: stream.isRunning)
                 Text(target.name).font(.system(size: 13, weight: .semibold))
-                Text(String(target.containerId.prefix(12)))
-                    .font(.system(size: 11, design: .monospaced))
-                    .foregroundStyle(.secondary)
+                if let containerId = target.containerId {
+                    Text(String(containerId.prefix(12)))
+                        .font(.system(size: 11, design: .monospaced))
+                        .foregroundStyle(.secondary)
+                } else if let run {
+                    RunStatusChip(run: run)
+                }
                 Spacer()
                 HStack(spacing: 6) {
                     Image(systemName: "line.3.horizontal.decrease").foregroundStyle(.secondary)
@@ -114,7 +131,17 @@ struct LogsView: View {
                     NSPasteboard.general.setString(visible.map(\.text).joined(separator: "\n"), forType: .string)
                 }
                 IconButton(symbol: "trash", help: "Clear") { stream.clear() }
-                IconButton(symbol: "arrow.clockwise", help: "Restart stream") { stream.start(containerId: target.containerId) }
+                if let run {
+                    Divider().frame(height: 16)
+                    IconButton(symbol: "arrow.clockwise", help: run.isAlive ? "Restart \(run.title)" : "Run \(run.title) again") {
+                        store.restartRun(run)
+                    }
+                    if run.isAlive {
+                        IconButton(symbol: "stop.circle", help: "Stop \(run.title)") { store.stopRun(run) }
+                    }
+                } else {
+                    IconButton(symbol: "arrow.clockwise", help: "Restart stream") { stream.start(target) }
+                }
             }
             .padding(.horizontal, 12)
             .padding(.vertical, 8)
@@ -145,10 +172,13 @@ struct LogsView: View {
             }
         }
         .frame(minWidth: 520, minHeight: 300)
-        .onAppear { stream.start(containerId: target.containerId) }
+        .onAppear { stream.start(target) }
         .onDisappear { stream.stop() }
     }
 
+    /// The run whose log this is, while devdash still lists it.
+    private var run: ManagedRun? { target.runId.flatMap(store.run(id:)) }
+
     private var visible: [LogStream.Line] {
         filter.isEmpty ? stream.lines : stream.lines.filter { $0.text.localizedCaseInsensitiveContains(filter) }
     }
diff --git a/macos/Sources/DevDashBar/Views/PopoverView.swift b/macos/Sources/DevDashBar/Views/PopoverView.swift
index 3c5652c..b65db4b 100644
--- a/macos/Sources/DevDashBar/Views/PopoverView.swift
+++ b/macos/Sources/DevDashBar/Views/PopoverView.swift
@@ -35,6 +35,8 @@ private struct RouteView: View {
     var body: some View {
         switch route {
         case let .processDetail(pid, name): ProcessDetailView(pid: pid, name: name)
+        case let .serverURL(pid, port): ServerURLView(pid: pid, port: port)
+        case let .worktrees(repo, cleanup): WorktreesView(repo: repo, cleanup: cleanup)
         case let .claudeProject(path): ClaudeProjectView(path: path)
         case .cleanup: CleanupView()
         case .graph: GraphView()
@@ -403,6 +405,11 @@ private struct FooterBar: View {
                 NSApp.activate(ignoringOtherApps: true)
             }
             FooterButton(title: "Graph", symbol: "point.3.connected.trianglepath.dotted") { store.push(.graph) }
+            if !store.worktreeRepos.isEmpty {
+                FooterButton(title: "Worktrees", symbol: "arrow.triangle.branch") {
+                    store.push(.worktrees(repo: nil, cleanup: false))
+                }
+            }
             if store.hasClaude {
                 FooterButton(title: "Activity", symbol: "square.grid.3x3.fill") { store.push(.heatmap) }
             }
diff --git a/macos/Sources/DevDashBar/Views/RunViews.swift b/macos/Sources/DevDashBar/Views/RunViews.swift
new file mode 100644
index 0000000..1bc7676
--- /dev/null
+++ b/macos/Sources/DevDashBar/Views/RunViews.swift
@@ -0,0 +1,318 @@
+import AppKit
+import SwiftUI
+
+// MARK: - Chips
+
+/// Marks a server devdash started, with the script's name.
+struct ManagedChip: View {
+    let run: ManagedRun
+
+    var body: some View {
+        HStack(spacing: 2) {
+            Image(systemName: run.restartOnCrash ? "arrow.triangle.2.circlepath" : "play.fill")
+                .font(.system(size: 7, weight: .bold))
+            Text(run.name)
+                .font(.system(size: 10, weight: .medium, design: .monospaced))
+                .lineLimit(1)
+        }
+        .foregroundStyle(Color.accentColor)
+        .padding(.horizontal, 5)
+        .padding(.vertical, 1)
+        .background(Color.accentColor.opacity(0.12), in: .capsule)
+        .fixedSize()
+        .help("Started by devdash: \(run.command)\(run.restartOnCrash ? "\nRestarts when it crashes" : "")")
+    }
+}
+
+struct RunStatusChip: View {
+    let run: ManagedRun
+
+    var body: some View {
+        let style = Self.style(run)
+        Text(style.label)
+            .font(.system(size: 10, weight: .semibold))
+            .foregroundStyle(style.color)
+            .padding(.horizontal, 7)
+            .padding(.vertical, 2)
+            .background(style.color.opacity(0.14), in: .capsule)
+    }
+
+    static func style(_ run: ManagedRun) -> (label: String, color: Color) {
+        switch run.status {
+        case "running": ("Running", .green)
+        case "restarting": ("Restarting", .orange)
+        case "crashed": ("Crashed", .red)
+        default: ("Exited", .secondary)
+        }
+    }
+}
+
+// MARK: - Run rows
+
+/// A run without a server row: starting, without a port (a worker, a watcher), or ended.
+struct RunRow: View {
+    @Environment(Store.self) private var store
+    @Environment(\.openWindow) private var openWindow
+    let run: ManagedRun
+    var showProject = false
+
+    var body: some View {
+        HoverRow(onTap: { openLogs(run, openWindow) }) {
+            HStack(spacing: 8) {
+                badge
+                VStack(alignment: .leading, spacing: 2) {
+                    HStack(spacing: 6) {
+                        Text(run.title)
+                            .font(.system(size: 12.5, weight: .semibold))
+                            .lineLimit(1)
+                        Text(run.command)
+                            .font(.system(size: 10, design: .monospaced))
+                            .foregroundStyle(.secondary)
+                            .lineLimit(1)
+                            .truncationMode(.tail)
+                    }
+                    Text(subtitle)
+                        .font(.system(size: 10.5))
+                        .foregroundStyle(run.isCrashed ? AnyShapeStyle(.red) : AnyShapeStyle(.secondary))
+                        .lineLimit(1)
+                        .truncationMode(.tail)
+                }
+            }
+        } metrics: {
+            RunStatusChip(run: run)
+        } actions: {
+            IconButton(symbol: "text.alignleft", help: "Show logs") { openLogs(run, openWindow) }
+            IconButton(symbol: run.isAlive ? "arrow.clockwise" : "play.fill", help: run.isAlive ? "Restart" : "Run again") {
+                store.restartRun(run)
+            }
+            if run.isAlive {
+                ConfirmIconButton(symbol: "stop.circle", help: "Stop \(run.title)", confirmLabel: "Stop?",
+                                  busy: store.isPending("run-\(run.id)")) {
+                    store.stopRun(run)
+                }
+            } else {
+                IconButton(symbol: "xmark", help: "Remove from the list") { store.clearRun(run) }
+            }
+        }
+        .contextMenu {
+            Button("Show Logs") { openLogs(run, openWindow) }
+            Button(run.isAlive ? "Restart \(run.title)" : "Run \(run.title) Again") { store.restartRun(run) }
+            RestartOnCrashToggle(run: run)
+            Divider()
+            Button("Reveal Log in Finder") { Launcher.revealInFinder(run.log) }
+            Button("Copy Command") { Pasteboard.copy(run.command) }
+            Divider()
+            if run.isAlive {
+                Button("Stop \(run.title)", role: .destructive) { store.stopRun(run) }
+            } else {
+                Button("Remove from List") { store.clearRun(run) }
+            }
+        }
+    }
+
+    private var badge: some View {
+        let (symbol, color): (String, Color) = switch run.status {
+        case "crashed": ("exclamationmark.triangle.fill", .red)
+        case "restarting": ("arrow.clockwise", .orange)
+        case "running": ("play.fill", .green)
+        default: ("stop.fill", .gray)
+        }
+        return ZStack {
+            RoundedRectangle(cornerRadius: 5).fill(color.opacity(0.16))
+            Image(systemName: symbol).font(.system(size: 9.5, weight: .semibold))
+        }
+        .foregroundStyle(color)
+        .frame(width: 22, height: 22)
+    }
+
+    private var subtitle: String {
+        var parts: [String] = []
+        if showProject { parts.append(run.projectName) }
+        switch run.status {
+        case "running":
+            parts.append(run.ports.isEmpty && Date().timeIntervalSince(run.startDate) < 30 ? "Starting" : "Running, no port")
+            parts.append("up " + run.startDate.formatted(.relative(presentation: .numeric, unitsStyle: .narrow)).replacingOccurrences(of: " ago", with: ""))
+        case "restarting":
+            parts.append("Crashed, restarting (\(run.restarts.count) of 3)")
+        case "crashed":
+            let code = run.exitCode.map { "exit code \($0)" } ?? "crashed"
+            parts.append(run.gaveUp ? "Crashed 3 times in 5 minutes, \(code)" : "Crashed with \(code)")
+            parts.append(run.endDate.formatted(.relative(presentation: .named)))
+        default:
+            parts.append("Exited " + run.endDate.formatted(.relative(presentation: .named)))
+        }
+        return parts.joined(separator: "  ·  ")
+    }
+}
+
+struct RestartOnCrashToggle: View {
+    @Environment(Store.self) private var store
+    let run: ManagedRun
+
+    var body: some View {
+        Toggle("Restart When It Crashes", isOn: Binding(
+            get: { run.restartOnCrash },
+            set: { store.setRestartOnCrash(run, $0) }
+        ))
+    }
+}
+
+@MainActor
+func openLogs(_ run: ManagedRun, _ openWindow: OpenWindowAction) {
+    openWindow(id: "logs", value: LogTarget(file: run.log, runId: run.id, name: "\(run.title) · \(run.projectName)"))
+    NSApp.activate(ignoringOtherApps: true)
+}
+
+// MARK: - Scripts menu
+
+/// "Run dev" and a Run submenu with every script, for a project's menu.
+struct RunMenuItems: View {
+    @Environment(Store.self) private var store
+    let project: RunnableProject
+
+    var body: some View {
+        if let script = project.defaultScript {
+            let live = store.liveRun(root: project.root, scriptId: script.id)
+            Button(live == nil ? "Run \(script.title)" : "Restart \(script.title)") {
+                if let live { store.restartRun(live) } else { store.run(script, in: project) }
+            }
+        }
+        if project.scripts.count > 1 {
+            Menu("Run") {
+                ForEach(sections, id: \.title) { section in
+                    Section(section.title) {
+                        ForEach(section.scripts) { script in
+                            let running = store.liveRun(root: project.root, scriptId: script.id) != nil
+                            Button(running ? "\(script.name) (running)" : script.name) { store.run(script, in: project) }
+                                .disabled(running)
+                                .help(script.command)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /// Root scripts, then one section per workspace package, then the Procfile.
+    private var sections: [(title: String, scripts: [RunScript])] {
+        var order: [String] = []
+        var groups: [String: [RunScript]] = [:]
+        for script in project.scripts {
+            let title = script.source == "package.json" ? (script.package.isEmpty ? "package.json" : script.package) : script.source
+            if groups[title] == nil { order.append(title) }
+            groups[title, default: []].append(script)
+        }
+        return order.map { ($0, groups[$0] ?? []) }
+    }
+}
+
+// MARK: - Ready to run
+
+/// Recent projects with nothing running, each with a play button.
+struct ReadyToRunSection: View {
+    @Environment(Store.self) private var store
+    static let id = "@ready"
+    @State private var hovering = false
+
+    var body: some View {
+        let projects = store.readyToRun.filter {
+            store.query.isEmpty || $0.name.matches(query: store.query) || $0.root.matches(query: store.query)
+        }
+        if !projects.isEmpty {
+            let expanded = !store.query.isEmpty || !store.isCollapsed(id: Self.id, byDefault: true)
+            HStack(spacing: 6) {
+                Image(systemName: "chevron.right")
+                    .font(.system(size: 9, weight: .bold))
+                    .foregroundStyle(.tertiary)
+                    .rotationEffect(.degrees(expanded ? 90 : 0))
+                    .frame(width: 10)
+                Text("Ready to run")
+                    .font(.system(size: 12, weight: .semibold))
+                    .foregroundStyle(.secondary)
+                Spacer(minLength: 4)
+                CountBadge(count: projects.count).fixedSize()
+            }
+            .padding(.horizontal, 8)
+            .frame(height: 26)
+            .background(.primary.opacity(hovering ? 0.05 : 0), in: .rect(cornerRadius: 7))
+            .contentShape(.rect)
+            .onTapGesture {
+                guard store.query.isEmpty else { return }
+                withAnimation(.snappy(duration: 0.22)) { store.toggleCollapsed(id: Self.id) }
+            }
+            .onHover { hovering = $0 }
+            .help("Recent projects with nothing running")
+            .padding(.top, 8)
+            if expanded {
+                ForEach(projects) { ReadyRow(project: $0) }
+            }
+        }
+    }
+}
+
+private struct ReadyRow: View {
+    @Environment(Store.self) private var store
+    let project: RunnableProject
+
+    var body: some View {
+        let script = project.defaultScript
+        HoverRow {
+            HStack(spacing: 8) {
+                ZStack {
+                    RoundedRectangle(cornerRadius: 5).fill(Color.secondary.opacity(0.14))
+                    Image(systemName: "folder").font(.system(size: 10, weight: .semibold))
+                }
+                .foregroundStyle(.secondary)
+                .frame(width: 22, height: 22)
+                VStack(alignment: .leading, spacing: 2) {
+                    Text(project.name).font(.system(size: 12.5, weight: .semibold)).lineLimit(1)
+                    Text(Format.shortPath(project.root))
+                        .font(.system(size: 10.5))
+                        .foregroundStyle(.secondary)
+                        .lineLimit(1)
+                        .truncationMode(.head)
+                }
+            }
+        } metrics: {
+            if let script {
+                Text(script.command)
+                    .font(.system(size: 10.5, design: .monospaced))
+                    .foregroundStyle(.secondary)
+                    .lineLimit(1)
+            }
+        } actions: {
+            IconButton(symbol: "chevron.left.forwardslash.chevron.right", help: "Open in editor") {
+                store.openInEditor(project.root)
+            }
+            if project.scripts.count > 1 {
+                Menu {
+                    RunMenuItems(project: project)
+                } label: {
+                    Image(systemName: "ellipsis")
+                        .font(.system(size: 11, weight: .semibold))
+                        .frame(width: 24, height: 24)
+                        .contentShape(.rect)
+                }
+                .menuStyle(.borderlessButton)
+                .menuIndicator(.hidden)
+                .fixedSize()
+                .help("Other scripts")
+            }
+            if let script {
+                IconButton(symbol: "play.fill", help: "Run \(script.command)", tint: .accentColor) {
+                    store.run(script, in: project)
+                }
+                .overlay {
+                    if store.isPending("run-\(project.root)#\(script.id)") { ProgressView().controlSize(.mini) }
+                }
+            }
+        }
+        .contextMenu {
+            RunMenuItems(project: project)
+            Divider()
+            Button("Open in Editor") { store.openInEditor(project.root) }
+            Button("Reveal in Finder") { Launcher.revealInFinder(project.root) }
+            Button("Open in Terminal") { Launcher.launchClaude(.shell, in: project.root) }
+        }
+    }
+}
diff --git a/macos/Sources/DevDashBar/Views/RunningTab.swift b/macos/Sources/DevDashBar/Views/RunningTab.swift
index b13e42a..6ba32c7 100644
--- a/macos/Sources/DevDashBar/Views/RunningTab.swift
+++ b/macos/Sources/DevDashBar/Views/RunningTab.swift
@@ -14,17 +14,19 @@ struct RunningGroup: Identifiable {
     var servers: [Server] = []
     var containers: [DockerContainer] = []
     var claude: [ClaudeInstance] = []
+    /// Runs devdash started that have no server row: starting, without a port, or ended.
+    var runs: [ManagedRun] = []
 
-    var count: Int { servers.count + containers.count + claude.count }
+    var count: Int { servers.count + containers.count + claude.count + runs.count }
     var isEmpty: Bool { count == 0 }
     var collapsedByDefault: Bool { kind == .services || kind == .other || kind == .background }
-    var stoppable: Int { servers.filter { !$0.isBackground }.count + containers.count }
+    var stoppable: Int { servers.filter { !$0.isBackground }.count + containers.count + runs.filter(\.isAlive).count }
     var canStop: Bool { (kind == .project || kind == .stack) && stoppable > 0 }
-    var latestStart: Double { servers.map(\.started).max() ?? 0 }
+    var latestStart: Double { (servers.map(\.started) + runs.map(\.started)).max() ?? 0 }
     var memoryMb: Double { servers.reduce(0) { $0 + $1.memoryMb } }
 
     /// Groups by project, with Services, Other and Background at the end.
-    static func byProject(servers: [Server], containers: [DockerContainer], claude: [ClaudeInstance]) -> [RunningGroup] {
+    static func byProject(servers: [Server], containers: [DockerContainer], claude: [ClaudeInstance], runs: [ManagedRun] = []) -> [RunningGroup] {
         var projects: [String: RunningGroup] = [:]
         var services = RunningGroup(id: "@services", kind: .services, name: "Services")
         var other = RunningGroup(id: "@other", kind: .other, name: "Other")
@@ -67,6 +69,11 @@ struct RunningGroup: Identifiable {
                 other.claude.append(instance)
             }
         }
+        for run in runs {
+            var group = project(run.projectRoot, run.projectName)
+            group.runs.append(run)
+            projects[run.projectRoot] = group
+        }
 
         background.servers.sort { $0.memoryMb > $1.memoryMb }
         let sorted = projects.values.sorted {
@@ -77,8 +84,8 @@ struct RunningGroup: Identifiable {
     }
 
     /// Dev servers, Compose stacks, Claude sessions, Services and Background, as the old Dev and Docker tabs did.
-    static func byType(servers: [Server], containers: [DockerContainer], claude: [ClaudeInstance]) -> [RunningGroup] {
-        var groups = [RunningGroup(id: "@servers", kind: .category, name: "Dev servers", servers: servers.filter { $0.kind == "app" })]
+    static func byType(servers: [Server], containers: [DockerContainer], claude: [ClaudeInstance], runs: [ManagedRun] = []) -> [RunningGroup] {
+        var groups = [RunningGroup(id: "@servers", kind: .category, name: "Dev servers", servers: servers.filter { $0.kind == "app" }, runs: runs)]
         let stacks = Dictionary(grouping: containers, by: \.composeProject).sorted { lhs, rhs in
             if lhs.key.isEmpty != rhs.key.isEmpty { return !lhs.key.isEmpty }
             return lhs.key < rhs.key
@@ -105,6 +112,7 @@ struct RunningGroup: Identifiable {
         group.servers = servers.filter { $0.matches(query: query) }
         group.containers = containers.filter { $0.matches(query: query) }
         group.claude = claude.filter { $0.project.matches(query: query) || $0.cwd.matches(query: query) }
+        group.runs = runs.filter { $0.name.matches(query: query) || $0.command.matches(query: query) || $0.package.matches(query: query) }
         return group.isEmpty ? nil : group
     }
 }
@@ -131,22 +139,27 @@ struct RunningTab: View {
 
     var body: some View {
         let claude = store.claudeInstances
+        let runs = store.runsWithoutServers()
         let all = store.grouping == .project
-            ? RunningGroup.byProject(servers: store.servers, containers: store.docker, claude: claude)
-            : RunningGroup.byType(servers: store.servers, containers: store.docker, claude: claude)
+            ? RunningGroup.byProject(servers: store.servers, containers: store.docker, claude: claude, runs: runs)
+            : RunningGroup.byType(servers: store.servers, containers: store.docker, claude: claude, runs: runs)
         let groups = all.compactMap { $0.filtered(by: store.query) }
 
         if all.isEmpty {
             EmptyState(
                 symbol: "moon.zzz",
                 title: "Nothing running",
-                message: "Dev servers in any language, Docker containers and Claude sessions show up here, grouped by project."
+                message: store.readyToRun.isEmpty
+                    ? "Dev servers in any language, Docker containers and Claude sessions show up here, grouped by project."
+                    : "Start a dev server from a recent project below, or from a terminal."
             )
+            ReadyToRunSection()
         } else if groups.isEmpty {
             VStack(spacing: 0) {
                 EmptyState(symbol: "magnifyingglass", title: "No matches for \u{201C}\(store.query)\u{201D}")
                 PillButton(title: "Clear filter") { store.query = "" }
             }
+            ReadyToRunSection()
         } else {
             ForEach(groups) { group in
                 let expanded = !store.query.isEmpty || !store.isCollapsed(group)
@@ -155,6 +168,7 @@ struct RunningTab: View {
                     GroupRows(group: group)
                 }
             }
+            ReadyToRunSection()
         }
     }
 }
@@ -169,6 +183,7 @@ private struct GroupRows: View {
         }
         ForEach(group.containers) { ContainerRow(container: $0) }
         ForEach(group.claude) { ClaudeInstanceRow(instance: $0, inGroup: inProject) }
+        ForEach(group.runs) { RunRow(run: $0, showProject: !inProject) }
     }
 }
 
@@ -194,7 +209,7 @@ private struct GroupHeader: View {
                 .lineLimit(1)
                 .layoutPriority(1)
             if let root = group.root, let branch = store.projects[root]?.branch, !branch.isEmpty {
-                BranchChip(branch: branch)
+                BranchChip(branch: branch, worktree: store.worktree(containing: root).map { !$0.isMain } ?? false)
             }
             if let root = group.root {
                 Text(Format.shortPath(root))
@@ -289,6 +304,14 @@ private struct GroupMenuItems: View {
                 Button("New Claude Session") { Launcher.launchClaude(.new, in: root) }
             }
             Button("Copy Path") { Pasteboard.copy(root) }
+            if let project = store.runnable[root], !project.scripts.isEmpty {
+                Divider()
+                RunMenuItems(project: project)
+            }
+            if let repo = store.worktreeRepo(containing: root) {
+                Divider()
+                Button("Worktrees (\(repo.worktrees.count))") { store.push(.worktrees(repo: repo.root, cleanup: false)) }
+            }
         }
         if group.canStop {
             Divider()
@@ -299,10 +322,12 @@ private struct GroupMenuItems: View {
 
 private struct BranchChip: View {
     let branch: String
+    /// The project is a linked worktree rather than the main checkout.
+    var worktree = false
 
     var body: some View {
         HStack(spacing: 3) {
-            Image(systemName: "arrow.triangle.branch").font(.system(size: 8.5, weight: .semibold))
+            Image(systemName: worktree ? "square.stack" : "arrow.triangle.branch").font(.system(size: 8.5, weight: .semibold))
             Text(branch)
                 .font(.system(size: 10, design: .monospaced))
                 .lineLimit(1)
@@ -314,6 +339,7 @@ private struct BranchChip: View {
         .padding(.horizontal, 5)
         .padding(.vertical, 1)
         .background(.primary.opacity(0.06), in: .capsule)
+        .help(worktree ? "Linked worktree on \(branch)" : "On \(branch)")
     }
 }
 
@@ -321,6 +347,7 @@ private struct BranchChip: View {
 
 struct ServerRow: View {
     @Environment(Store.self) private var store
+    @Environment(\.openWindow) private var openWindow
     let server: Server
     /// Show the project name, for rows outside a project group.
     var showProject = false
@@ -340,7 +367,8 @@ struct ServerRow: View {
                                 .foregroundStyle(.secondary)
                                 .lineLimit(1)
                         }
-                        ForEach(server.ports.prefix(3), id: \.self) { PortChip(port: $0) }
+                        if let run { ManagedChip(run: run) }
+                        ForEach(server.ports.prefix(3), id: \.self) { PortChip(port: $0, url: server.url(for: $0).local) }
                         if server.ports.count > 3 {
                             Text("+\(server.ports.count - 3)").font(.system(size: 10)).foregroundStyle(.secondary)
                         }
@@ -358,22 +386,47 @@ struct ServerRow: View {
                 Metric(text: Format.memory(server.memoryMb))
             }
         } actions: {
-            if let port = server.ports.first {
-                IconButton(symbol: "safari", help: "Open localhost:\(port)") { Launcher.openPort(port) }
-            }
-            IconButton(symbol: "chevron.left.forwardslash.chevron.right", help: "Open in editor") {
-                store.openInEditor(server.cwdFull)
+            if let url = server.primaryURL {
+                IconButton(symbol: "safari", help: "Open \(url.local)") { Launcher.openURL(url.local) }
+                if server.isApp {
+                    IconButton(symbol: "qrcode", help: "Open on your phone", action: showQRCode)
+                }
             }
-            ConfirmIconButton(symbol: "xmark.octagon", help: "Kill PID \(server.pid)", busy: store.isPending("pid-\(server.pid)")) {
-                store.kill(pid: server.pid, label: server.displayName)
+            if let run {
+                IconButton(symbol: "text.alignleft", help: "Show logs") { openLogs(run, openWindow) }
+                IconButton(symbol: "arrow.clockwise", help: "Restart \(run.title)") { store.restartRun(run) }
+                    .overlay { if store.isPending("run-\(run.id)") { ProgressView().controlSize(.mini) } }
+                ConfirmIconButton(symbol: "stop.circle", help: "Stop \(run.title) (\(run.command))", confirmLabel: "Stop?",
+                                  busy: store.isPending("run-\(run.id)")) {
+                    store.stopRun(run)
+                }
+            } else {
+                IconButton(symbol: "chevron.left.forwardslash.chevron.right", help: "Open in editor") {
+                    store.openInEditor(server.cwdFull)
+                }
+                ConfirmIconButton(symbol: "xmark.octagon", help: "Kill PID \(server.pid)", busy: store.isPending("pid-\(server.pid)")) {
+                    store.kill(pid: server.pid, label: server.displayName)
+                }
             }
         }
         .contextMenu {
+            if let run {
+                Button("Restart \(run.title)") { store.restartRun(run) }
+                Button("Stop \(run.title)") { store.stopRun(run) }
+                Button("Show Logs") { openLogs(run, openWindow) }
+                RestartOnCrashToggle(run: run)
+                Divider()
+            }
             ForEach(server.ports, id: \.self) { port in
-                Button("Open localhost:\(String(port))") { Launcher.openPort(port) }
+                let url = server.url(for: port)
+                Button("Open \(url.local.replacingOccurrences(of: "http://", with: ""))") { Launcher.openURL(url.local) }
             }
-            if let port = server.ports.first {
-                Button("Copy URL") { Pasteboard.copy("http://localhost:\(port)") }
+            if let url = server.primaryURL {
+                Button("Copy URL") { Pasteboard.copy(url.local) }
+                if let lan = url.lan {
+                    Button("Copy Network URL") { Pasteboard.copy(lan) }
+                }
+                Button("Show QR Code", action: showQRCode)
                 Divider()
             }
             Button("Show Details", action: showDetail)
@@ -388,6 +441,9 @@ struct ServerRow: View {
         }
     }
 
+    /// The run devdash started this server in.
+    private var run: ManagedRun? { server.runId.flatMap(store.run(id:)) }
+
     private var subtitle: String {
         guard showProject else { return server.shortCommand }
         let place = server.projectName.isEmpty ? server.cwd : server.projectName
@@ -397,6 +453,11 @@ struct ServerRow: View {
     private func showDetail() {
         store.push(.processDetail(pid: server.pid, name: server.displayName))
     }
+
+    private func showQRCode() {
+        guard let port = server.ports.first else { return }
+        store.push(.serverURL(pid: server.pid, port: port))
+    }
 }
 
 /// A small colored mark for a runtime, container or Claude session.
diff --git a/macos/Sources/DevDashBar/Views/ServerURLView.swift b/macos/Sources/DevDashBar/Views/ServerURLView.swift
new file mode 100644
index 0000000..335f23e
--- /dev/null
+++ b/macos/Sources/DevDashBar/Views/ServerURLView.swift
@@ -0,0 +1,172 @@
+import CoreImage.CIFilterBuiltins
+import SwiftUI
+
+// MARK: - Server URLs and QR code
+
+/// A server's local and network URLs, with a QR code to open it on a phone on the same network.
+struct ServerURLView: View {
+    @Environment(Store.self) private var store
+    let pid: Int
+    @State private var port: Int
+
+    init(pid: Int, port: Int) {
+        self.pid = pid
+        _port = State(initialValue: port)
+    }
+
+    private var server: Server? { store.servers.first { $0.pid == pid } }
+
+    var body: some View {
+        VStack(spacing: 0) {
+            SubPageHeader(title: server?.displayName ?? "Server", subtitle: subtitle)
+            Divider().opacity(0.5)
+            if let server {
+                ScrollView {
+                    VStack(spacing: 12) {
+                        if server.ports.count > 1 {
+                            Picker("Port", selection: $port) {
+                                ForEach(server.ports, id: \.self) { Text(verbatim: ":\($0)").tag($0) }
+                            }
+                            .pickerStyle(.segmented)
+                            .labelsHidden()
+                        }
+                        NetworkSection(server: server, url: server.url(for: port))
+                        URLField(label: "This Mac", url: server.url(for: port).local)
+                    }
+                    .padding(12)
+                }
+                .scrollIndicators(.never)
+            } else {
+                EmptyState(symbol: "stop.circle", title: "The server stopped", message: "PID \(pid) is no longer running.")
+                Spacer()
+            }
+        }
+    }
+
+    private var subtitle: String? {
+        guard let server else { return nil }
+        let place = server.projectName.isEmpty ? server.cwd : server.projectName
+        return place.isEmpty ? "PID \(pid)" : "\(place)  ·  PID \(pid)"
+    }
+}
+
+private struct NetworkSection: View {
+    let server: Server
+    let url: ServerURL
+
+    var body: some View {
+        if let lan = url.lan {
+            VStack(spacing: 10) {
+                QRCode(text: lan)
+                    .frame(width: 184, height: 184)
+                    .padding(10)
+                    .background(.white, in: .rect(cornerRadius: 12))
+                Text("Scan with a phone on the same Wi-Fi")
+                    .font(.system(size: 11.5))
+                    .foregroundStyle(.secondary)
+                URLField(label: "Network", url: lan)
+            }
+            .frame(maxWidth: .infinity)
+            .card()
+        } else if url.exposed {
+            Notice(
+                symbol: "wifi.slash",
+                title: "This Mac isn't on a network",
+                message: "Connect to Wi-Fi or Ethernet to open it on another device."
+            )
+        } else {
+            Notice(
+                symbol: "lock.laptopcomputer",
+                title: "Only this Mac can open it",
+                message: "Port \(url.port) listens on localhost, so a phone can't reach it.",
+                hint: server.exposeHint
+            )
+        }
+    }
+}
+
+private struct Notice: View {
+    let symbol: String
+    let title: String
+    let message: String
+    var hint: String?
+
+    var body: some View {
+        VStack(spacing: 8) {
+            Image(systemName: symbol)
+                .font(.system(size: 26, weight: .light))
+                .foregroundStyle(.secondary)
+            Text(title).font(.system(size: 13, weight: .semibold))
+            Text(message)
+                .font(.system(size: 11.5))
+                .foregroundStyle(.secondary)
+                .multilineTextAlignment(.center)
+            if let hint, !hint.isEmpty {
+                Text(hint)
+                    .font(.system(size: 11))
+                    .multilineTextAlignment(.center)
+                    .textSelection(.enabled)
+                    .padding(.horizontal, 10)
+                    .padding(.vertical, 7)
+                    .frame(maxWidth: .infinity)
+                    .background(Color.accentColor.opacity(0.1), in: .rect(cornerRadius: 8))
+                    .padding(.top, 4)
+            }
+        }
+        .frame(maxWidth: .infinity)
+        .padding(.vertical, 18)
+        .padding(.horizontal, 8)
+        .card()
+    }
+}
+
+private struct URLField: View {
+    @Environment(Store.self) private var store
+    let label: String
+    let url: String
+
+    var body: some View {
+        HStack(spacing: 6) {
+            Text(label)
+                .font(.system(size: 10.5, weight: .medium))
+                .foregroundStyle(.secondary)
+                .frame(width: 58, alignment: .leading)
+            Text(url)
+                .font(.system(size: 11, design: .monospaced))
+                .lineLimit(1)
+                .truncationMode(.middle)
+                .textSelection(.enabled)
+                .frame(maxWidth: .infinity, alignment: .leading)
+            IconButton(symbol: "doc.on.doc", help: "Copy \(url)", size: 22) {
+                Pasteboard.copy(url)
+                store.showToast("Copied \(url)")
+            }
+            IconButton(symbol: "safari", help: "Open \(url)", size: 22) { Launcher.openURL(url) }
+        }
+        .card(radius: 8, padding: 6)
+    }
+}
+
+/// A QR code drawn with CoreImage, scaled without smoothing so the modules stay sharp.
+struct QRCode: View {
+    let text: String
+
+    var body: some View {
+        if let image = Self.image(for: text) {
+            Image(nsImage: image)
+                .interpolation(.none)
+                .resizable()
+                .accessibilityLabel("QR code for \(text)")
+        }
+    }
+
+    static func image(for text: String) -> NSImage? {
+        let filter = CIFilter.qrCodeGenerator()
+        filter.message = Data(text.utf8)
+        filter.correctionLevel = "M"
+        // Scaled up here: SwiftUI smooths a 25-pixel image even with interpolation off.
+        guard let output = filter.outputImage?.transformed(by: CGAffineTransform(scaleX: 12, y: 12)),
+              let cgImage = CIContext().createCGImage(output, from: output.extent) else { return nil }
+        return NSImage(cgImage: cgImage, size: output.extent.size)
+    }
+}
diff --git a/macos/Sources/DevDashBar/Views/WorktreesView.swift b/macos/Sources/DevDashBar/Views/WorktreesView.swift
new file mode 100644
index 0000000..06abf41
--- /dev/null
+++ b/macos/Sources/DevDashBar/Views/WorktreesView.swift
@@ -0,0 +1,264 @@
+import SwiftUI
+
+// MARK: - Worktrees
+
+/// Linked git worktrees of every repository devdash knows about, with what's safe to remove.
+struct WorktreesView: View {
+    @Environment(Store.self) private var store
+    let repo: String?
+    @State private var cleanup: Bool
+
+    init(repo: String?, cleanup: Bool) {
+        self.repo = repo
+        _cleanup = State(initialValue: cleanup)
+    }
+
+    private var repos: [WorktreeRepo] {
+        store.worktreeRepos.filter { repo == nil || $0.root == repo }
+    }
+
+    private func shown(_ repo: WorktreeRepo) -> [Worktree] {
+        guard cleanup else { return repo.worktrees }
+        let idle = Set(store.idleMergedWorktrees)
+        return repo.worktrees.filter(idle.contains)
+    }
+
+    var body: some View {
+        VStack(spacing: 0) {
+            SubPageHeader(title: title, subtitle: subtitle) {
+                IconButton(symbol: "arrow.clockwise", help: "Scan again") { store.refreshWorktrees() }
+            }
+            Divider().opacity(0.5)
+            Picker("Show", selection: $cleanup) {
+                Text("All").tag(false)
+                Text("Merged and idle (\(store.idleMergedWorktrees.count))").tag(true)
+            }
+            .pickerStyle(.segmented)
+            .labelsHidden()
+            .padding(.horizontal, 12)
+            .padding(.vertical, 8)
+
+            let sections = repos.map { ($0, shown($0)) }.filter { !$0.1.isEmpty }
+            if sections.isEmpty {
+                EmptyState(
+                    symbol: "arrow.triangle.branch",
+                    title: cleanup ? "Nothing to clean up" : "No worktrees",
+                    message: cleanup
+                        ? "Merged worktrees appear here once nothing has run in them for a day."
+                        : "Repositories you work in that have linked worktrees, such as the ones Claude Code creates, show up here."
+                )
+                Spacer()
+            } else {
+                ScrollView {
+                    LazyVStack(alignment: .leading, spacing: 2) {
+                        ForEach(sections, id: \.0.id) { repo, worktrees in
+                            RepoHeader(repo: repo, count: worktrees.count)
+                            ForEach(worktrees) { WorktreeRow(worktree: $0, repo: repo) }
+                        }
+                        Text("Worktrees with uncommitted changes, or with a server or Claude session running in them, can't be removed here.")
+                            .font(.system(size: 10.5))
+                            .foregroundStyle(.tertiary)
+                            .padding(.horizontal, 8)
+                            .padding(.top, 10)
+                    }
+                    .padding(.horizontal, 8)
+                    .padding(.bottom, 10)
+                }
+                .scrollIndicators(.never)
+                .task(id: sections.flatMap(\.1).map(\.path)) {
+                    await store.loadSizes(for: sections.flatMap(\.1))
+                }
+            }
+        }
+    }
+
+    private var title: String {
+        if let repo, let name = store.worktreeRepos.first(where: { $0.root == repo })?.name { return "\(name) worktrees" }
+        return "Worktrees"
+    }
+
+    private var subtitle: String {
+        let count = repos.reduce(0) { $0 + $1.worktrees.count }
+        let repoCount = repos.count
+        return repo == nil
+            ? "\(count) in \(repoCount) repositor\(repoCount == 1 ? "y" : "ies")"
+            : "\(count) worktree\(count == 1 ? "" : "s")"
+    }
+}
+
+private struct RepoHeader: View {
+    let repo: WorktreeRepo
+    let count: Int
+
+    var body: some View {
+        HStack(spacing: 6) {
+            Text(repo.name).font(.system(size: 12, weight: .semibold)).lineLimit(1)
+            if !repo.defaultBranch.isEmpty {
+                Text(repo.defaultBranch)
+                    .font(.system(size: 10, design: .monospaced))
+                    .foregroundStyle(.secondary)
+                    .padding(.horizontal, 5)
+                    .padding(.vertical, 1)
+                    .background(.primary.opacity(0.06), in: .capsule)
+                    .help("Branches merged into \(repo.defaultBranch) count as merged")
+            }
+            Text(Format.shortPath(repo.root))
+                .font(.system(size: 10))
+                .foregroundStyle(.tertiary)
+                .lineLimit(1)
+                .truncationMode(.head)
+            Spacer(minLength: 4)
+            CountBadge(count: count).fixedSize()
+        }
+        .padding(.horizontal, 8)
+        .frame(height: 26)
+        .padding(.top, 8)
+    }
+}
+
+private struct WorktreeRow: View {
+    @Environment(Store.self) private var store
+    let worktree: Worktree
+    let repo: WorktreeRepo
+
+    var body: some View {
+        let status = store.status(of: worktree)
+        HoverRow(onTap: { store.openInEditor(worktree.path) }) {
+            HStack(spacing: 8) {
+                CreatorBadge(worktree: worktree)
+                VStack(alignment: .leading, spacing: 2) {
+                    HStack(spacing: 6) {
+                        Text(worktree.displayBranch)
+                            .font(.system(size: 12, weight: .semibold, design: .monospaced))
+                            .lineLimit(1)
+                            .truncationMode(.middle)
+                        if worktree.isMain {
+                            Text("main checkout").font(.system(size: 10, weight: .medium)).foregroundStyle(.secondary)
+                        }
+                        if worktree.locked {
+                            Image(systemName: "lock.fill").font(.system(size: 9)).foregroundStyle(.secondary).help("Locked")
+                        }
+                    }
+                    Text(subtitle)
+                        .font(.system(size: 10.5))
+                        .foregroundStyle(.secondary)
+                        .lineLimit(1)
+                        .truncationMode(.middle)
+                }
+            }
+            .help(worktree.subject.isEmpty ? worktree.path : "\(worktree.subject)\n\(worktree.path)")
+        } metrics: {
+            WorktreeStatusChip(status: status, changes: worktree.changes)
+        } actions: {
+            IconButton(symbol: "chevron.left.forwardslash.chevron.right", help: "Open in editor") {
+                store.openInEditor(worktree.path)
+            }
+            IconButton(symbol: "terminal", help: "Open in Terminal") { Launcher.launchClaude(.shell, in: worktree.path) }
+            if let reason = blocker(status: status) {
+                IconButton(symbol: "folder", help: "Reveal in Finder. \(reason)") { Launcher.revealInFinder(worktree.path) }
+            } else {
+                ConfirmIconButton(
+                    symbol: "trash", help: removeHelp, confirmLabel: "Remove?",
+                    busy: store.isPending("wt-\(worktree.path)")
+                ) {
+                    store.remove(worktree, deleteBranch: worktree.merged)
+                }
+            }
+        }
+        .contextMenu {
+            Button("Open in Editor") { store.openInEditor(worktree.path) }
+            Button("Open in Terminal") { Launcher.launchClaude(.shell, in: worktree.path) }
+            if store.hasClaude {
+                Button("New Claude Session") { Launcher.launchClaude(.new, in: worktree.path) }
+            }
+            Button("Reveal in Finder") { Launcher.revealInFinder(worktree.path) }
+            Divider()
+            Button("Copy Path") { Pasteboard.copy(worktree.path) }
+            if !worktree.branch.isEmpty {
+                Button("Copy Branch Name") { Pasteboard.copy(worktree.branch) }
+            }
+            Divider()
+            if let reason = blocker(status: status) {
+                Button("Can't remove: \(reason)") {}.disabled(true)
+            } else {
+                Button("Remove Worktree", role: .destructive) { store.remove(worktree, deleteBranch: false) }
+                if worktree.merged && !worktree.branch.isEmpty {
+                    Button("Remove Worktree and Branch", role: .destructive) { store.remove(worktree, deleteBranch: true) }
+                }
+            }
+        }
+    }
+
+    private var subtitle: String {
+        // The repository header already shows the main checkout's folder.
+        var parts = worktree.isMain ? [] : [worktree.folder]
+        parts.append(worktree.lastActivity.formatted(.relative(presentation: .named)))
+        if let size = store.worktreeSizes[worktree.path] { parts.append(ByteFormat.string(size)) }
+        let activity = store.activity(in: worktree)
+        if !activity.servers.isEmpty { parts.append("\(activity.servers.count) server\(activity.servers.count == 1 ? "" : "s")") }
+        if !activity.sessions.isEmpty { parts.append("Claude") }
+        return parts.joined(separator: "  ·  ")
+    }
+
+    private var removeHelp: String {
+        worktree.merged && !worktree.branch.isEmpty
+            ? "Remove the worktree and delete branch \(worktree.branch)"
+            : "Remove the worktree (the branch stays)"
+    }
+
+    /// Why this worktree can't be removed from devdash, if it can't.
+    private func blocker(status: String) -> String? {
+        if worktree.isMain { return "it's the main checkout" }
+        if status == "running" { return "something is running in it" }
+        if worktree.changes > 0 { return "it has uncommitted changes" }
+        if worktree.locked { return "it's locked" }
+        return nil
+    }
+}
+
+/// Who made the worktree: Claude Code gets its mark, the main checkout a house, the rest a branch.
+private struct CreatorBadge: View {
+    let worktree: Worktree
+
+    var body: some View {
+        if worktree.createdBy == "claude" && !worktree.isMain {
+            RuntimeBadge(runtime: "claude")
+        } else {
+            let color = worktree.isMain ? Color.secondary : Color.accentColor
+            ZStack {
+                RoundedRectangle(cornerRadius: 5).fill(color.opacity(0.16))
+                Image(systemName: worktree.isMain ? "house.fill" : "arrow.triangle.branch")
+                    .font(.system(size: 10, weight: .semibold))
+            }
+            .foregroundStyle(color)
+            .frame(width: 22, height: 22)
+            .help(worktree.createdBy.isEmpty ? "Worktree" : "Created by \(worktree.createdBy)")
+        }
+    }
+}
+
+struct WorktreeStatusChip: View {
+    let status: String
+    var changes = 0
+
+    var body: some View {
+        let style = Self.style(status, changes: changes)
+        Text(style.label)
+            .font(.system(size: 10, weight: .semibold))
+            .foregroundStyle(style.color)
+            .padding(.horizontal, 7)
+            .padding(.vertical, 2)
+            .background(style.color.opacity(0.14), in: .capsule)
+    }
+
+    static func style(_ status: String, changes: Int) -> (label: String, color: Color) {
+        switch status {
+        case "running": ("Running", .green)
+        case "changes": ("\(changes) change\(changes == 1 ? "" : "s")", .orange)
+        case "merged": ("Merged", .purple)
+        case "stale": ("Stale", .secondary)
+        case "missing": ("Missing", .red)
+        default: ("Active", .accentColor)
+        }
+    }
+}
diff --git a/macos/Sources/DevDashBar/WhatsNew.swift b/macos/Sources/DevDashBar/WhatsNew.swift
index e6205a4..e5cbe41 100644
--- a/macos/Sources/DevDashBar/WhatsNew.swift
+++ b/macos/Sources/DevDashBar/WhatsNew.swift
@@ -14,6 +14,30 @@ enum WhatsNew {
     }
 
     static let releases: [Release] = [
+        Release(version: "0.7.0", entries: [
+            Entry(symbol: "play.fill", title: "Run dev servers",
+                  detail: "Run dev, or any package.json script or Procfile entry, from a project's menu. Recent projects wait under Ready to run."),
+            Entry(symbol: "arrow.clockwise", title: "Restart, stop and logs",
+                  detail: "Servers devdash started get Restart, Stop and Logs, and can restart on their own when they crash."),
+            Entry(symbol: "exclamationmark.triangle", title: "Crashes and busy ports",
+                  detail: "A crash or a port held by another process shows up in Needs you, with the logs or a Stop and run button."),
+        ]),
+        Release(version: "0.6.0", entries: [
+            Entry(symbol: "arrow.triangle.branch", title: "Worktrees",
+                  detail: "Every git worktree of your repositories, with changes, merged branches and what runs in them. Open it from the footer."),
+            Entry(symbol: "trash", title: "Clean up merged worktrees",
+                  detail: "Remove a merged worktree and its branch in one click. Worktrees with changes or something running are never touched."),
+            Entry(symbol: "bell.badge", title: "In Needs you",
+                  detail: "Merged worktrees nothing has touched for a day show up at the top."),
+        ]),
+        Release(version: "0.5.0", entries: [
+            Entry(symbol: "qrcode", title: "Open on your phone",
+                  detail: "Hover a dev server and click the QR button. Scan the code with a phone on the same Wi-Fi to open the server there."),
+            Entry(symbol: "lock.laptopcomputer", title: "Localhost-only servers",
+                  detail: "Servers a phone can't reach say so, with the flag that fixes it, such as --host for Vite."),
+            Entry(symbol: "link", title: "Copy URLs",
+                  detail: "Option-click a port to copy its URL. Server menus also have Copy Network URL."),
+        ]),
         Release(version: "0.4.0", entries: [
             Entry(symbol: "cup.and.saucer", title: "Keep awake",
                   detail: "The cup in the header keeps your Mac awake and, after a minute idle, nudges the cursor so Teams and Slack keep you active."),
diff --git a/macos/scripts/build-app.sh b/macos/scripts/build-app.sh
index 2b69e0d..f912051 100755
--- a/macos/scripts/build-app.sh
+++ b/macos/scripts/build-app.sh
@@ -162,21 +162,22 @@ notarize() {
 
 # The ticket lookup behind stapler goes to CloudKit, which drops connections on CI runners
 # (error 68) and can lag a few seconds behind notarization (error 65), so retry it.
-staple() {
+# Usage: stapler staple|validate <path>
+stapler() {
     local attempt
     for attempt in 1 2 3 4 5; do
-        xcrun stapler staple "$1" && return 0
-        info "Stapling $(basename "$1") failed (attempt $attempt), retrying in $((attempt * 15))s"
+        xcrun stapler "$1" "$2" && return 0
+        info "stapler $1 $(basename "$2") failed (attempt $attempt), retrying in $((attempt * 15))s"
         sleep $((attempt * 15))
     done
-    xcrun stapler staple "$1"
+    xcrun stapler "$1" "$2"
 }
 
 info "Creating $ZIP"
 ditto -c -k --keepParent "$OUT" "$ZIP"
 if [[ -n "${NOTARY_PROFILE:-}" ]]; then
     notarize "$ZIP"
-    staple "$OUT"
+    stapler staple "$OUT"
     rm -f "$ZIP"
     ditto -c -k --keepParent "$OUT" "$ZIP"
 fi
@@ -185,17 +186,23 @@ info "Creating $DMG"
 STAGE="$(mktemp -d)"
 cp -R "$OUT" "$STAGE/"
 ln -s /Applications "$STAGE/Applications"
-hdiutil create -quiet -volname "$APP_NAME" -srcfolder "$STAGE" -ov -format ULMO "$DMG"
+# hdiutil fails now and then on CI runners with "Resource busy", so retry it.
+for attempt in 1 2 3 4; do
+    hdiutil create -volname "$APP_NAME" -srcfolder "$STAGE" -ov -format ULMO "$DMG" && break
+    [[ $attempt -eq 4 ]] && exit 1
+    info "hdiutil create failed (attempt $attempt), retrying in $((attempt * 10))s"
+    sleep $((attempt * 10))
+done
 rm -rf "$STAGE"
 if [[ -n "${SIGN_IDENTITY:-}" ]]; then
     codesign --force --timestamp --sign "$SIGN_IDENTITY" "$DMG"
 fi
 if [[ -n "${NOTARY_PROFILE:-}" ]]; then
     notarize "$DMG"
-    staple "$DMG"
+    stapler staple "$DMG"
     info "Checking Gatekeeper"
-    xcrun stapler validate "$OUT"
-    xcrun stapler validate "$DMG"
+    stapler validate "$OUT"
+    stapler validate "$DMG"
     spctl --assess --type execute --verbose "$OUT"
     spctl --assess --type open --context context:primary-signature --verbose "$DMG"
 fi
diff --git a/screenshots/app/claude.png b/screenshots/app/claude.png
index 4816368..e3592ff 100644
Binary files a/screenshots/app/claude.png and b/screenshots/app/claude.png differ
diff --git a/screenshots/app/heatmap.png b/screenshots/app/heatmap.png
index 4c76cdd..f06124a 100644
Binary files a/screenshots/app/heatmap.png and b/screenshots/app/heatmap.png differ
diff --git a/screenshots/app/hero.png b/screenshots/app/hero.png
index bbbe91d..8b22bd6 100644
Binary files a/screenshots/app/hero.png and b/screenshots/app/hero.png differ
diff --git a/screenshots/app/logs.png b/screenshots/app/logs.png
new file mode 100644
index 0000000..08900cc
Binary files /dev/null and b/screenshots/app/logs.png differ
diff --git a/screenshots/app/port-conflict.png b/screenshots/app/port-conflict.png
new file mode 100644
index 0000000..73c507e
Binary files /dev/null and b/screenshots/app/port-conflict.png differ
diff --git a/screenshots/app/project.png b/screenshots/app/project.png
index 369298a..c6d3dfb 100644
Binary files a/screenshots/app/project.png and b/screenshots/app/project.png differ
diff --git a/screenshots/app/qrcode-localhost.png b/screenshots/app/qrcode-localhost.png
new file mode 100644
index 0000000..6621e91
Binary files /dev/null and b/screenshots/app/qrcode-localhost.png differ
diff --git a/screenshots/app/qrcode.png b/screenshots/app/qrcode.png
new file mode 100644
index 0000000..e9c666f
Binary files /dev/null and b/screenshots/app/qrcode.png differ
diff --git a/screenshots/app/ready.png b/screenshots/app/ready.png
new file mode 100644
index 0000000..68aca3e
Binary files /dev/null and b/screenshots/app/ready.png differ
diff --git a/screenshots/app/running-collapsed.png b/screenshots/app/running-collapsed.png
index b7c5469..998463b 100644
Binary files a/screenshots/app/running-collapsed.png and b/screenshots/app/running-collapsed.png differ
diff --git a/screenshots/app/running.png b/screenshots/app/running.png
index 58dd166..4acd320 100644
Binary files a/screenshots/app/running.png and b/screenshots/app/running.png differ
diff --git a/screenshots/app/system.png b/screenshots/app/system.png
index 29a7fbe..29037b4 100644
Binary files a/screenshots/app/system.png and b/screenshots/app/system.png differ
diff --git a/screenshots/app/usage.png b/screenshots/app/usage.png
index c3f51f4..b0671d6 100644
Binary files a/screenshots/app/usage.png and b/screenshots/app/usage.png differ
diff --git a/screenshots/app/worktrees.png b/screenshots/app/worktrees.png
new file mode 100644
index 0000000..4287785
Binary files /dev/null and b/screenshots/app/worktrees.png differ
diff --git a/scripts/screenshots.sh b/scripts/screenshots.sh
index 1c65a07..0c30921 100755
--- a/scripts/screenshots.sh
+++ b/scripts/screenshots.sh
@@ -6,7 +6,7 @@ set -euo pipefail
 REPO="$(cd "$(dirname "$0")/.." && pwd)"
 DEVDASH="$REPO/.venv/bin/devdash"
 OUT="$REPO/screenshots"
-APP_SHOTS=(hero running running-collapsed system claude usage cleanup graph heatmap project detail)
+APP_SHOTS=(hero running running-collapsed system claude usage cleanup graph heatmap project detail qrcode qrcode-localhost worktrees ready port-conflict logs)
 
 echo "==> Terminal UI"
 "$REPO/.venv/bin/python" "$REPO/scripts/tui_screenshots.py" "$OUT"
diff --git a/tests/test_network.py b/tests/test_network.py
new file mode 100644
index 0000000..1507747
--- /dev/null
+++ b/tests/test_network.py
@@ -0,0 +1,71 @@
+import socket
+from types import SimpleNamespace
+
+from devdash import network
+
+
+def _addr(ip, family=socket.AF_INET):
+    return SimpleNamespace(family=family, address=ip)
+
+
+def _up(isup=True):
+    return SimpleNamespace(isup=isup)
+
+
+def test_lan_ip_prefers_up_en_interfaces_with_private_ipv4():
+    addrs = {
+        "lo0": [_addr("127.0.0.1")],
+        "utun3": [_addr("10.8.0.2")],
+        "en1": [_addr("192.168.1.30")],
+        "en0": [_addr("fe80::1", socket.AF_INET6), _addr("169.254.10.2"), _addr("192.168.1.24")],
+    }
+    stats = {"lo0": _up(), "utun3": _up(), "en0": _up(), "en1": _up(False)}
+    assert network.pick_lan_ip(addrs, stats) == "192.168.1.24"
+
+
+def test_lan_ip_none_when_offline():
+    assert network.pick_lan_ip({"en0": [_addr("192.168.1.24")]}, {"en0": _up(False)}) is None
+    assert network.pick_lan_ip({"en0": [_addr("8.8.8.8")]}, {"en0": _up()}) is None
+
+
+def test_exposed_bind_addresses():
+    lan = "192.168.1.24"
+    assert network.is_exposed({"0.0.0.0"}, lan)
+    assert network.is_exposed({"::"}, lan)
+    assert network.is_exposed({"192.168.1.24"}, lan)
+    assert network.is_exposed({"127.0.0.1", "::"}, None)
+    assert not network.is_exposed({"127.0.0.1"}, lan)
+    assert not network.is_exposed({"::1"}, lan)
+    assert not network.is_exposed({"127.0.0.1", "::1", "fe80::1%lo0"}, lan)
+
+
+def test_server_urls(monkeypatch):
+    monkeypatch.setattr(network, "lan_ip", lambda: "192.168.1.24")
+    urls = network.server_urls(1, {5173: {"::1"}, 3000: {"::"}}, probe_tls=False)
+    assert urls == [
+        {"port": 3000, "local": "http://localhost:3000", "lan": "http://192.168.1.24:3000", "exposed": True},
+        {"port": 5173, "local": "http://localhost:5173", "lan": None, "exposed": False},
+    ]
+
+
+def test_server_urls_offline(monkeypatch):
+    monkeypatch.setattr(network, "lan_ip", lambda: None)
+    [url] = network.server_urls(1, {3000: {"0.0.0.0"}}, probe_tls=False)
+    assert url["exposed"] and url["lan"] is None
+
+
+def test_tls_probe_on_closed_port_is_http():
+    with socket.socket() as sock:
+        sock.bind(("127.0.0.1", 0))
+        port = sock.getsockname()[1]
+    [url] = network.server_urls(99999, {port: {"127.0.0.1"}}, probe_tls=True)
+    assert url["local"] == f"http://localhost:{port}"
+
+
+def test_expose_hints():
+    assert "--host" in network.expose_hint("vite", "vite --port 5173", 5173)
+    assert "-H 0.0.0.0" in network.expose_hint("next dev", "next dev", 3000)
+    assert "0.0.0.0:8000" in network.expose_hint("manage.py", "python manage.py runserver", 8000)
+    assert "0.0.0.0" in network.expose_hint("server.mjs", "node server.mjs", 8765)
+    assert "--host 0.0.0.0" in network.expose_hint("storybook", "storybook dev -p 6006", 6006)
+    assert "--host 0.0.0.0" in network.expose_hint("rsbuild", "rsbuild dev", 3001)
diff --git a/tests/test_runnable.py b/tests/test_runnable.py
new file mode 100644
index 0000000..004f6ca
--- /dev/null
+++ b/tests/test_runnable.py
@@ -0,0 +1,75 @@
+import json
+from pathlib import Path
+
+from devdash import runnable
+
+
+def _package(folder: Path, scripts: dict, **extra) -> None:
+    folder.mkdir(parents=True, exist_ok=True)
+    (folder / "package.json").write_text(json.dumps({"name": folder.name, "scripts": scripts, **extra}))
+
+
+def test_order_skips_lifecycle_and_hooks(tmp_path):
+    _package(tmp_path, {
+        "build": "vite build", "postinstall": "patch-package", "predev": "gen", "preview": "vite preview",
+        "dev": "vite", "lint": "eslint .", "prepare": "husky",
+    })
+    assert [s.name for s in runnable.scripts(str(tmp_path))] == ["dev", "preview", "build", "lint"]
+
+
+def test_package_manager_from_lockfile_and_field(tmp_path):
+    for lockfile, manager in (("pnpm-lock.yaml", "pnpm"), ("yarn.lock", "yarn"), ("bun.lockb", "bun"), ("", "npm")):
+        folder = tmp_path / (manager + lockfile)
+        _package(folder, {"dev": "vite"})
+        if lockfile:
+            (folder / lockfile).touch()
+        assert runnable.scripts(str(folder))[0].command == f"{manager} run dev"
+    field = tmp_path / "field"
+    _package(field, {"dev": "vite"}, packageManager="pnpm@9.12.0")
+    assert runnable.scripts(str(field))[0].command == "pnpm run dev"
+
+
+def test_workspaces_offer_server_scripts_of_each_package(tmp_path):
+    _package(tmp_path, {"dev": "turbo dev", "build": "turbo build"}, workspaces=["apps/*"])
+    (tmp_path / "yarn.lock").touch()
+    _package(tmp_path / "apps" / "web", {"dev": "next dev", "build": "next build"})
+    _package(tmp_path / "apps" / "api", {"start": "node server.js", "test": "vitest"})
+    scripts = {s.id: s for s in runnable.scripts(str(tmp_path))}
+    assert list(scripts) == ["dev", "build", "apps/api:start", "apps/web:dev"]
+    web = scripts["apps/web:dev"]
+    assert (web.command, web.cwd, web.package) == ("yarn run dev", str(tmp_path / "apps" / "web"), "web")
+
+
+def test_pnpm_workspace_file(tmp_path):
+    _package(tmp_path, {})
+    (tmp_path / "pnpm-workspace.yaml").write_text("packages:\n  - 'packages/*'\n  - \"!packages/legacy\"\ncatalog:\n  - nope\n")
+    (tmp_path / "pnpm-lock.yaml").touch()
+    _package(tmp_path / "packages" / "site", {"dev": "astro dev"})
+    assert [(s.id, s.command) for s in runnable.scripts(str(tmp_path))] == [("packages/site:dev", "pnpm run dev")]
+
+
+def test_procfile_dev_wins_over_procfile(tmp_path):
+    (tmp_path / "Procfile").write_text("web: bundle exec puma\n")
+    (tmp_path / "Procfile.dev").write_text("# local\nweb: bin/rails server -p 3000\ncss: bin/rails tailwindcss:watch\n")
+    scripts = runnable.scripts(str(tmp_path))
+    assert [(s.id, s.command) for s in scripts] == [
+        ("Procfile.dev:web", "bin/rails server -p 3000"),
+        ("Procfile.dev:css", "bin/rails tailwindcss:watch"),
+    ]
+
+
+def test_default_is_last_run_else_first(tmp_path):
+    _package(tmp_path, {"dev": "vite", "storybook": "storybook dev"})
+    scripts = runnable.scripts(str(tmp_path))
+    assert runnable.default_script(scripts, None).id == "dev"
+    assert runnable.default_script(scripts, "storybook").id == "storybook"
+    assert runnable.default_script(scripts, "gone").id == "dev"
+
+
+def test_ports_in_commands():
+    assert runnable.ports_in("vite --port 5174") == {5174}
+    assert runnable.ports_in("storybook dev -p 6006") == {6006}
+    assert runnable.ports_in("PORT=4000 node server.js") == {4000}
+    assert runnable.ports_in("gunicorn app:app --bind 0.0.0.0:8001") == {8001}
+    assert runnable.ports_in("rails server -b 0.0.0.0") == set()
+    assert runnable.ports_in("next dev") == set()
diff --git a/tests/test_supervisor.py b/tests/test_supervisor.py
new file mode 100644
index 0000000..385609e
--- /dev/null
+++ b/tests/test_supervisor.py
@@ -0,0 +1,186 @@
+import os
+import socket
+import subprocess
+import sys
+import time
+
+import pytest
+
+from devdash import supervisor as sup
+from devdash.supervisor import PortConflict, Supervisor
+
+
+def _free_port() -> int:
+    with socket.socket() as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+def _wait(condition, timeout=5.0) -> bool:
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if condition():
+            return True
+        time.sleep(0.05)
+    return False
+
+
+def _listening(port: int) -> bool:
+    with socket.socket() as s:
+        return s.connect_ex(("127.0.0.1", port)) == 0
+
+
+@pytest.fixture
+def project(tmp_path):
+    port = _free_port()
+    folder = tmp_path / "app"
+    folder.mkdir()
+    py = sys.executable
+    (folder / "Procfile.dev").write_text(
+        f"web: {py} -m http.server {port} --bind 127.0.0.1\n"
+        # A shell with a child, like `npm run dev` starting node: stop has to reach both.
+        f"pair: {py} -m http.server {port} --bind 127.0.0.1 & sleep 60\n"
+        "crash: echo boom; exit 3\n"
+    )
+    return folder, port
+
+
+@pytest.fixture
+def supervisor(tmp_path):
+    made = []
+
+    def make():
+        s = Supervisor(state_dir=tmp_path / "state", env=lambda: dict(os.environ))
+        made.append(s)
+        return s
+
+    yield make
+    for s in made:
+        for run_id in list(s.runs):
+            try:
+                s.stop(run_id)
+            except Exception:
+                pass
+
+
+def test_start_logs_and_stop(project, supervisor):
+    folder, port = project
+    s = supervisor()
+    run = s.start(str(folder), "Procfile.dev:web")
+    assert run.status == "running" and run.pid > 0
+    assert _wait(lambda: _listening(port))
+    assert s.run_for_pid(run.pid) == run.id
+    s.stop(run.id)
+    assert not _listening(port)
+    assert run.id not in s.runs
+    assert "devdash:" in open(run.log).read()
+    assert s.last[str(folder)] == "Procfile.dev:web"
+
+
+def test_stop_reaches_children_in_the_group(project, supervisor):
+    folder, port = project
+    s = supervisor()
+    run = s.start(str(folder), "Procfile.dev:pair")
+    assert _wait(lambda: _listening(port))
+    s.stop(run.id)
+    assert not sup._group_alive(run.pid)
+    assert not _listening(port)
+
+
+def test_restart_gets_a_new_process(project, supervisor):
+    folder, port = project
+    s = supervisor()
+    first = s.start(str(folder), "Procfile.dev:web")
+    assert _wait(lambda: _listening(port))
+    old_pid = first.pid
+    second = s.restart(first.id)
+    assert second.pid != old_pid and second.status == "running"
+    assert _wait(lambda: _listening(port))
+
+
+def test_already_running_is_refused(project, supervisor):
+    folder, _ = project
+    s = supervisor()
+    s.start(str(folder), "Procfile.dev:web")
+    with pytest.raises(ValueError, match="already running"):
+        s.start(str(folder), "Procfile.dev:web")
+
+
+def test_crash_loop_gives_up(project, supervisor, monkeypatch):
+    monkeypatch.setattr(sup, "CRASH_DELAY", 0.05)
+    folder, _ = project
+    s = supervisor()
+    run = s.start(str(folder), "Procfile.dev:crash")
+    assert _wait(lambda: run.status == "crashed")
+    assert run.exit_code == 3 and not run.restarts
+
+    s.set_restart_on_crash(run.id, True)
+    run = s.start(str(folder), "Procfile.dev:crash")
+    assert _wait(lambda: run.gave_up, timeout=8)
+    assert run.status == "crashed" and len(run.restarts) == sup.CRASH_LIMIT
+
+
+def test_reload_picks_up_running_servers(project, supervisor):
+    folder, port = project
+    first = supervisor()
+    run = first.start(str(folder), "Procfile.dev:web")
+    assert _wait(lambda: _listening(port))
+
+    # A new bridge, as after the menu bar app restarts.
+    second = supervisor()
+    reloaded = second.runs[run.id]
+    assert reloaded.status == "running" and second.run_for_pid(run.pid) == run.id
+    second.stop(run.id)
+    assert not _listening(port)
+    first.runs.clear()
+
+
+def test_reload_marks_runs_that_died_unwatched_as_exited(project, supervisor):
+    folder, _ = project
+    first = supervisor()
+    dead = subprocess.Popen(["true"], start_new_session=True)
+    dead.wait()
+    run = sup.Run(id="x", project_root=str(folder), project_name="app", script_id="Procfile.dev:web", name="web",
+                  command="true", cwd=str(folder), package="", log="", pid=dead.pid, status="running")
+    first.runs[run.id] = run
+    first._save()
+    first.runs.clear()
+
+    reloaded = supervisor().runs["x"]
+    assert reloaded.status == "exited" and reloaded.exit_code is None
+
+
+def test_port_held_by_another_process(project, supervisor, tmp_path):
+    folder, port = project
+    s = supervisor()
+    run = s.start(str(folder), "Procfile.dev:web")
+    assert _wait(lambda: _listening(port))
+    s.poll([{"pid": run.pid, "ports": [port], "label": "http.server"}])
+    assert s.runs[run.id].ports == [port]
+    s.stop(run.id, forget=False)
+
+    holder = subprocess.Popen(
+        [sys.executable, "-m", "http.server", str(port), "--bind", "127.0.0.1"],
+        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True,
+    )
+    try:
+        assert _wait(lambda: _listening(port))
+        servers = [{"pid": holder.pid, "ports": [port], "label": "http.server", "project_name": "other"}]
+        with pytest.raises(PortConflict) as conflict:
+            s.start(str(folder), "Procfile.dev:web", servers=servers)
+        assert (conflict.value.port, conflict.value.pid) == (port, holder.pid)
+        assert str(conflict.value) == f"Port {port} is held by PID {holder.pid} (http.server in other)"
+    finally:
+        holder.terminate()
+        holder.wait()
+
+
+def test_missing_folder_fails_without_a_phantom_run(project, supervisor, monkeypatch):
+    folder, _ = project
+    s = supervisor()
+    # A workspace package runs in its own folder; one that was deleted can't start.
+    gone = sup.runnable.Script(id="gone", name="gone", command="true", source="Procfile.dev", cwd=str(folder / "nope"))
+    monkeypatch.setattr(sup.runnable, "find", lambda root, script_id: gone)
+    with pytest.raises(ValueError, match="Could not start gone"):
+        s.start(str(folder), "gone")
+    assert not s.runs
diff --git a/tests/test_worktrees.py b/tests/test_worktrees.py
new file mode 100644
index 0000000..c0a62f4
--- /dev/null
+++ b/tests/test_worktrees.py
@@ -0,0 +1,97 @@
+import os
+import subprocess
+import time
+
+import pytest
+
+from devdash import worktrees
+
+
+def git(cwd, *args):
+    subprocess.run(["git", "-C", str(cwd), *args], check=True, capture_output=True)
+
+
+@pytest.fixture
+def repo(tmp_path):
+    """main, plus worktrees that are merged, have changes, have unmerged commits, and run something."""
+    root = tmp_path / "app"
+    root.mkdir()
+    git(root, "init", "-q", "-b", "main")
+    git(root, "config", "user.email", "t@example.com")
+    git(root, "config", "user.name", "t")
+    (root / "README").write_text("hi\n")
+    git(root, "add", ".")
+    git(root, "commit", "-qm", "init")
+    for name in ("merged", "changes", "ahead", "busy"):
+        git(root, "worktree", "add", "-q", "-b", name, str(tmp_path / name))
+    (tmp_path / "changes" / "new.txt").write_text("x\n")
+    (tmp_path / "ahead" / "file").write_text("x\n")
+    git(tmp_path / "ahead", "add", ".")
+    git(tmp_path / "ahead", "commit", "-qm", "work")
+    return os.path.realpath(tmp_path)
+
+
+def by_branch(repo_dir):
+    found = worktrees.scan({f"{repo_dir}/app"})
+    assert len(found) == 1
+    return {w.branch: w for w in found[0].worktrees}
+
+
+def test_parse_porcelain():
+    text = (
+        "worktree /r\nHEAD 1234567890abcdef\nbranch refs/heads/main\n\n"
+        "worktree /r/.claude/worktrees/a\nHEAD abcdef1234567890\ndetached\nlocked\n\n"
+        "worktree /gone\nHEAD 1111111111111111\nbranch refs/heads/x\nprunable gitdir file points to non-existent location\n"
+    )
+    main, agent, gone = worktrees.parse_porcelain(text)
+    assert main.is_main and main.branch == "main" and main.head == "1234567"
+    assert not agent.is_main and agent.branch == "" and agent.locked
+    assert gone.prunable and gone.branch == "x"
+    assert worktrees.created_by(agent.path) == "claude"
+
+
+def test_status_priority():
+    now = time.time()
+    old = now - 30 * 86400
+    assert worktrees.status(worktrees.Worktree("p", "b", "h", prunable=True, changes=2), now) == "missing"
+    assert worktrees.status(worktrees.Worktree("p", "b", "h", changes=2, merged=True), now) == "changes"
+    assert worktrees.status(worktrees.Worktree("p", "b", "h", merged=True, last_touched=old), now) == "merged"
+    assert worktrees.status(worktrees.Worktree("p", "b", "h", last_touched=old, last_commit=old), now) == "stale"
+    assert worktrees.status(worktrees.Worktree("p", "b", "h", last_touched=now), now) == "active"
+
+
+def test_scan(repo):
+    wts = by_branch(repo)
+    assert wts["main"].is_main
+    assert wts["merged"].merged and wts["merged"].status == "merged"
+    assert wts["changes"].changes == 1 and wts["changes"].status == "changes"
+    assert not wts["ahead"].merged and wts["ahead"].status == "active"
+    assert wts["ahead"].subject == "work"
+
+
+def test_scan_skips_repos_without_worktrees(tmp_path):
+    git(tmp_path, "init", "-q")
+    assert worktrees.scan({str(tmp_path)}) == []
+
+
+def test_remove_refuses_main_changes_and_busy(repo):
+    with pytest.raises(ValueError, match="main checkout"):
+        worktrees.remove(f"{repo}/app", False, [])
+    with pytest.raises(ValueError, match="uncommitted"):
+        worktrees.remove(f"{repo}/changes", False, [])
+    with pytest.raises(ValueError, match="running"):
+        worktrees.remove(f"{repo}/busy", False, [f"{repo}/busy/src"])
+    assert os.path.isdir(f"{repo}/changes") and os.path.isdir(f"{repo}/busy")
+
+
+def test_remove_merged_deletes_branch(repo):
+    result = worktrees.remove(f"{repo}/merged", True, [f"{repo}/busy"])
+    assert result["branch_deleted"] and not os.path.exists(f"{repo}/merged")
+    assert "merged" not in by_branch(repo)
+
+
+def test_remove_keeps_unmerged_branch(repo):
+    result = worktrees.remove(f"{repo}/ahead", True, [])
+    assert not result["branch_deleted"] and "not fully merged" in result["note"]
+    assert not os.path.exists(f"{repo}/ahead")
+    subprocess.run(["git", "-C", f"{repo}/app", "rev-parse", "--verify", "ahead"], check=True, capture_output=True)