diff --git a/.claude/launch.json b/.claude/launch.json
new file mode 100644
index 00000000..02be1cdc
--- /dev/null
+++ b/.claude/launch.json
@@ -0,0 +1,11 @@
+{
+    "version": "0.0.1",
+    "configurations": [
+        {
+            "name": "web-ui",
+            "runtimeExecutable": "npm",
+            "runtimeArgs": ["run", "api"],
+            "port": 3010
+        }
+    ]
+}
diff --git a/.gitignore b/.gitignore
index 356fb010..aa2cfb2f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,4 +9,5 @@ note
 .DS_Store
 .playwright-chromium-installed
 .stfolder/
-.env
\ No newline at end of file
+.env
+scheduled_tasks.json
\ No newline at end of file
diff --git a/PROXY_GUIDE.vi.md b/PROXY_GUIDE.vi.md
new file mode 100644
index 00000000..f968f439
--- /dev/null
+++ b/PROXY_GUIDE.vi.md
@@ -0,0 +1,336 @@
+# Hướng dẫn cài đặt Proxy — Microsoft Rewards Script
+
+Tài liệu này dành cho người **chưa từng dùng proxy bao giờ**. Đọc từ trên xuống, làm đúng thứ tự là được.
+
+---
+
+## 1. Proxy là gì? (giải thích bằng ví dụ đời thường)
+
+Hãy tưởng tượng bạn muốn gửi một lá thư nhưng **không muốn người nhận biết địa chỉ nhà bạn**.
+
+- **Không có proxy:** bạn tự đi bộ đến nhà người nhận, họ thấy mặt bạn và biết bạn ở đâu.
+- **Có proxy:** bạn đưa lá thư cho một người trung gian. Người đó đi giao thư. Người nhận chỉ thấy **địa chỉ của người trung gian**, không thấy bạn.
+
+**Proxy chính là "người trung gian" đó.** Nó là một máy chủ trung gian nằm giữa máy tính của bạn và trang web Microsoft, giúp:
+
+1. **Giấu địa chỉ IP thật của bạn** — Microsoft chỉ thấy IP của proxy.
+2. **Tạo cảm giác mỗi tài khoản đến từ một nơi khác nhau** — thay vì 4 tài khoản cùng phát ra từ một IP nhà bạn.
+
+### Vì sao điều này quan trọng với tool này?
+
+Nếu bạn chạy 4 tài khoản Microsoft Rewards **từ cùng một IP nhà**, Microsoft thấy 4 tài khoản hoạt động chung một chỗ, cùng giờ, cùng kiểu — đó là dấu hiệu rất rõ của bot. **Proxy giúp mỗi tài khoản trông như một người riêng biệt ngồi ở một thành phố riêng.**
+
+> ⚠️ **Nói thẳng:** proxy **giảm** nguy cơ bị khóa tài khoản, nhưng **không loại bỏ hoàn toàn**. Microsoft vẫn có thể phát hiện bot bằng nhiều cách khác. Đừng dùng proxy rồi nghĩ mình an toàn tuyệt đối.
+
+---
+
+## 2. Bạn có thật sự cần proxy không?
+
+| Tình huống                               | Có cần proxy?                               |
+| ---------------------------------------- | ------------------------------------------- |
+| Chỉ chạy **1 tài khoản**                 | ❌ Không cần. IP nhà bạn là đủ tự nhiên.    |
+| Chạy **2–3 tài khoản**, chấp nhận rủi ro | ⚠️ Nên có, nhưng chưa bắt buộc              |
+| Chạy **4 tài khoản trở lên**             | ✅ **Rất nên có.** Mỗi tài khoản một proxy. |
+| Tài khoản đã từng bị khóa/cảnh báo       | ✅ Nên có, kèm proxy **dân cư** (xem mục 3) |
+
+**Nếu bạn chỉ có 1 tài khoản, hãy bỏ qua toàn bộ tài liệu này** — thêm proxy vào chỉ làm tool chạy chậm hơn và dễ lỗi hơn mà không được gì.
+
+---
+
+## 3. Chọn loại proxy nào?
+
+Tool này hỗ trợ 4 loại, nhưng **thực tế bạn chỉ nên dùng 2 loại đầu**:
+
+| Loại      | Ghi trong ô "Proxy address" | Dùng được mật khẩu? | Nên dùng?                           |
+| --------- | --------------------------- | ------------------- | ----------------------------------- |
+| **HTTP**  | `http://...`                | ✅ Có               | ✅ **Phổ biến nhất, chọn cái này**  |
+| **HTTPS** | `https://...`               | ✅ Có               | ✅ Tốt, mã hóa đường truyền         |
+| SOCKS4    | `socks4://...`              | ❌ **Không**        | ⚠ Chỉ khi proxy không cần đăng nhập |
+| SOCKS5    | `socks5://...`              | ❌ **Không**        | ⚠ Chỉ khi proxy không cần đăng nhập |
+
+### Vì sao SOCKS không dùng được mật khẩu?
+
+Tool điều khiển trình duyệt bằng thư viện tên **Patchright**, và Patchright **không hỗ trợ proxy SOCKS có xác thực**. Nếu bạn nhập tài khoản/mật khẩu cho proxy SOCKS, Web UI sẽ **báo lỗi ngay** và không lưu:
+
+```
+SOCKS5 proxy authentication is not supported by Patchright
+```
+
+→ **Cách xử lý:** hoặc dùng proxy HTTP/HTTPS (có mật khẩu), hoặc dùng proxy SOCKS **không cần** đăng nhập. Đừng cố nhập mật khẩu cho SOCKS.
+
+### Dân cư (residential) hay Trung tâm dữ liệu (datacenter)?
+
+- **Datacenter** (giá rẻ, ví dụ $1–3/tháng): IP thuộc về trung tâm dữ liệu. Microsoft **biết rõ** dải IP này. Vẫn dùng được nhưng tỉ lệ bị nghi ngờ cao hơn.
+- **Residential** (đắt hơn, $3–15/tháng): IP thật của hộ gia đình. Tự nhiên nhất, khó bị phát hiện nhất. **Đây là loại nên dùng nếu bạn nghiêm túc.**
+
+### Mua ở đâu?
+
+Bạn cần tự mua — tool không kèm proxy. Một số nhà cung cấp phổ biến:
+
+- Webshare, IPRoyal, Smartproxy, Oxylabs, Bright Data
+
+**Khi mua, bạn sẽ nhận được 4 thông tin** — hãy ghi lại đủ 4:
+
+```
+Địa chỉ (host):  proxy.provider.com     ← thứ này vào ô "Proxy address"
+Cổng (port):     8080                    ← vào ô "Port"
+Tên đăng nhập:   myuser123               ← vào ô "Username"
+Mật khẩu:         aBcD1234xyz            ← vào ô "Password"
+```
+
+> 💡 **Mẹo tiết kiệm:** mua gói **nhiều proxy cùng lúc** (ví dụ 5 proxy). Thường nhà cung cấp bán theo gói, mua lẻ 1 cái thường đắt hơn nhiều.
+
+### ⚠️ Phân biệt nơi BÁN proxy riêng và nơi cho DANH SÁCH proxy công cộng
+
+Đây là chỗ rất nhiều người mua nhầm. Có **hai loại website hoàn toàn khác nhau**:
+
+| Loại website                                    | Bạn nhận được gì                                     | Dùng cho tool này?      |
+| ----------------------------------------------- | ---------------------------------------------------- | ----------------------- |
+| **Nhà bán proxy riêng** (Webshare, IPRoyal...)  | 1 proxy **riêng của bạn**, có tài khoản/mật khẩu     | ✅ **Đúng thứ bạn cần** |
+| **Danh sách proxy công cộng** (free proxy list) | Hàng nghìn địa chỉ IP dùng chung với **cả thế giới** | ❌ **Đừng dùng**        |
+
+**Vì sao danh sách proxy công cộng không dùng được?**
+
+1. **Ai cũng dùng được** — hàng nghìn người khác cũng đang dùng đúng cái IP đó. Microsoft thấy một IP có 500 người đăng nhập khác nhau thì đó là dấu hiệu xấu, không phải tốt.
+2. **Tốc độ rất chậm và hay chết** — proxy công cộng thường chết sau vài giờ, thậm chí vài phút. Bạn sẽ phải thay liên tục.
+3. **Không có tài khoản/mật khẩu** — nghĩa là bạn không kiểm soát được gì, và không biết ai đang đọc dữ liệu đi qua đó.
+4. **Nhiều cái là mồi** — một số trang cố tình đăng proxy để thu thập dữ liệu người dùng. **Tuyệt đối không đăng nhập tài khoản Microsoft qua proxy công cộng không rõ nguồn.**
+
+> 🚨 **Dấu hiệu nhận biết:** nếu trang web hiển thị một **bảng dài hàng nghìn dòng IP:port** và cho bạn bấm "Copy" miễn phí mà **không hỏi mật khẩu đăng nhập proxy** — đó là danh sách công cộng. Đừng dùng cho tài khoản Microsoft.
+>
+> Ngược lại, trang **bán** proxy sẽ cho bạn **một** địa chỉ duy nhất (hoặc một gói vài cái), kèm **username và password riêng của bạn**.
+
+---
+
+## 4. Cách nhập proxy vào Web UI (từng bước)
+
+**Điều kiện:** Web UI đang chạy (xem `WEB_UI_GUIDE.vi.md` mục 3). Tool **KHÔNG được chạy** khi bạn đang sửa proxy.
+
+### Bước 1 — Mở trình soạn proxy
+
+Trong danh sách **Ready to Execute**, tìm dòng tài khoản bạn muốn gán proxy. Bấm nút **Proxy** trên dòng đó.
+
+Khung **"Proxy for [email tài khoản]"** sẽ hiện ra ngay bên dưới. Tên tài khoản hiện ở tiêu đề để bạn chắc chắn mình đang sửa đúng người.
+
+### Bước 2 — Điền thông tin
+
+| Trường            | Điền gì                          | Ví dụ                       |
+| ----------------- | -------------------------------- | --------------------------- |
+| **Proxy address** | Địa chỉ proxy, **kèm `http://`** | `http://proxy.provider.com` |
+| **Port**          | Cổng, số từ 1 đến 65535          | `8080`                      |
+| **Username**      | Tên đăng nhập proxy (nếu có)     | `myuser123`                 |
+| **Password**      | Mật khẩu proxy (nếu có)          | `aBcD1234xyz`               |
+
+**Ba lưu ý quan trọng:**
+
+1. **Phải có `http://` ở đầu.** Gõ `proxy.provider.com` không có `http://` thì tool tự hiểu là `http://` (vẫn chạy được), nhưng cứ gõ đầy đủ cho chắc.
+2. **KHÔNG nhập tài khoản/mật khẩu vào ô Proxy address.** Viết `http://user:pass@proxy.com` là **sai** — Web UI sẽ báo lỗi. Tài khoản và mật khẩu phải nằm ở 2 ô riêng.
+3. **Username và Password phải điền cùng nhau.** Có tên mà không có mật khẩu (hoặc ngược lại) sẽ bị từ chối.
+
+### Bước 3 — Chọn công tắc "Use for API requests too"
+
+Công tắc này quyết định proxy **che những gì**. Đọc kỹ mục 5 bên dưới rồi mới bật.
+
+### Bước 4 — Bấm **Save Proxy**
+
+- Thấy thông báo xanh (toast) **"Proxy saved"** = thành công.
+- Dòng tài khoản sẽ hiện **huy hiệu xanh `host:port`** bên cạnh email → bạn biết tài khoản này đã có proxy.
+- Thay đổi **chỉ áp dụng cho lần chạy tới**. Nếu tool đang chạy, bấm **Stop** rồi chạy lại.
+
+### Xóa proxy (khi không cần nữa)
+
+Mở lại khung, bấm **Remove Proxy** → xác nhận. Proxy của tài khoản đó bị xóa sạch.
+
+Hoặc: xóa trắng ô **Proxy address** rồi bấm **Save Proxy** — kết quả giống hệt.
+
+---
+
+## 5. Công tắc "Use for API requests too" — quan trọng nhất
+
+Đây là chỗ **hầu hết người mới hiểu sai**. Tool này liên lạc với Microsoft qua **2 đường riêng biệt**:
+
+```
+        ┌─────────────────────────────────────┐
+        │        Máy tính của bạn             │
+        └──────────┬──────────────┬───────────┘
+                   │              │
+        (1) Trình duyệt     (2) Gọi API trực tiếp
+            (Edge)              (tính điểm, nhiệm vụ)
+                   │              │
+                   ▼              ▼
+              ┌─────────┐   ┌─────────┐
+              │ PROXY?  │   │ PROXY?  │  ← công tắc quyết định ở đây
+              └────┬────┘   └────┬────┘
+                   │              │
+                   └──────┬───────┘
+                          ▼
+                   Microsoft Rewards
+```
+
+| Công tắc           | Trình duyệt (Edge) | Gọi API trực tiếp         |
+| ------------------ | ------------------ | ------------------------- |
+| **TẮT** (mặc định) | ✅ Đi qua proxy    | ❌ Đi thẳng từ IP nhà bạn |
+| **BẬT**            | ✅ Đi qua proxy    | ✅ Đi qua proxy           |
+
+### Vậy nên chọn cái nào?
+
+**Khuyên dùng: TẮT** (để nguyên mặc định).
+
+**Lý do:** Nhiều proxy (nhất là loại rẻ) **chặn hoặc làm hỏng** các request API. Khi bật công tắc này, tool hay gặp lỗi kiểu:
+
+```
+Failed to fetch dashboard data
+Request timeout
+403 Forbidden
+```
+
+Nếu bạn đang gặp mấy lỗi này sau khi bật proxy → **tắt công tắc đi và chạy lại**. Đây là nguyên nhân số 1.
+
+**Khi nào nên BẬT?**
+
+- Bạn dùng proxy **residential loại tốt**, đã kiểm tra chạy ổn với API.
+- Bạn chạy **nhiều tài khoản** và muốn **che tuyệt đối** — không muốn bất kỳ request nào lộ IP nhà.
+- Bạn đã bị Microsoft cảnh báo và muốn che chắn tối đa.
+
+**Quy tắc thực tế:** Chạy thử với công tắc **TẮT** trước. Nếu mọi thứ suôn sẻ và bạn muốn an toàn hơn, hãy thử **BẬT** rồi quan sát log. Gặp lỗi thì tắt lại.
+
+---
+
+## 6. Nguyên tắc vàng: MỘT tài khoản = MỘT proxy
+
+Đây là sai lầm phổ biến nhất và cũng là sai lầm **nguy hiểm nhất**.
+
+| Cách làm                                  | Kết quả                                                                                                                                          |
+| ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 4 tài khoản dùng **4 proxy khác nhau**    | ✅ Đúng. Mỗi tài khoản như một người riêng.                                                                                                      |
+| 4 tài khoản dùng **chung 1 proxy**        | ❌ **Vô nghĩa.** Microsoft vẫn thấy 4 tài khoản cùng một IP — y như không dùng proxy. Thậm chí tệ hơn, vì giờ nó là IP của proxy (dễ bị gắn cờ). |
+| 3 tài khoản dùng proxy, 1 tài khoản không | ⚠ Tài khoản không proxy vẫn lộ IP nhà. Chấp nhận được nhưng không tối ưu.                                                                        |
+
+**Nhớ kỹ:** Proxy chỉ có tác dụng khi **mỗi tài khoản có một IP riêng**. Dùng chung thì công cốc.
+
+> 💡 Nếu ngân sách hạn chế: **giảm số tài khoản** xuống bằng số proxy bạn có, thay vì dùng chung proxy. Chạy 3 tài khoản tử tế an toàn hơn 6 tài khoản dùng chung 2 proxy.
+
+---
+
+## 7. Kiểm tra proxy có hoạt động không
+
+Có proxy "trông đúng" nhưng thực tế không chạy. Cách kiểm tra **trước khi** chạy tool:
+
+### Cách 1 — Kiểm tra bằng trình duyệt (dễ nhất, khuyên dùng)
+
+1. Mở **Edge** hoặc **Chrome**.
+2. Vào trang: `https://whatismyipaddress.com`
+3. Xem **IP hiện tại của bạn** và ghi nhớ nó (ví dụ `113.161.x.x`).
+4. Cài extension proxy (ví dụ _Proxy SwitchyOmega_) → nhập đúng thông tin proxy của bạn → bật lên.
+5. Tải lại trang `whatismyipaddress.com`.
+6. **IP phải ĐỔI thành IP khác.** Nếu vẫn là IP cũ → proxy không hoạt động, đừng nhập vào tool.
+
+### Cách 2 — Kiểm tra bằng dòng lệnh
+
+Mở Terminal trong thư mục tool và chạy (thay thông tin proxy của bạn vào):
+
+```bash
+curl -x http://myuser123:aBcD1234xyz@proxy.provider.com:8080 https://api.ipify.org
+```
+
+- In ra một địa chỉ IP → ✅ proxy chạy tốt.
+- Báo lỗi `Could not resolve host`, `Connection refused`, `407 Proxy Authentication Required` → proxy có vấn đề. Xem mục 8.
+
+> ⚠ Trong lệnh `curl` ở trên, tài khoản/mật khẩu **nằm trong cùng chuỗi** với `@`. Đó là **cú pháp của riêng `curl`**, KHÔNG phải cách nhập vào Web UI. Trong Web UI, bạn luôn tách ra 2 ô riêng.
+
+---
+
+## 8. Lỗi thường gặp & cách sửa
+
+### ❌ "Proxy URL is required when other proxy settings are configured"
+
+Bạn điền Port/Username/Password nhưng **để trống Proxy address**. Hoặc ngược lại, muốn xóa proxy nhưng chỉ xóa mỗi địa chỉ.
+**Sửa:** điền đủ địa chỉ, hoặc bấm **Remove Proxy** để xóa sạch mọi thứ.
+
+### ❌ "Proxy port must be an integer from 1 to 65535"
+
+Ô Port trống, hoặc bạn gõ chữ, hoặc gõ số ngoài khoảng (ví dụ `70000`, `0`).
+**Sửa:** nhập số từ `1` đến `65535`. Cổng phổ biến: `8080`, `3128`, `1080`.
+
+### ❌ "Put proxy credentials in the username/password fields, not in the proxy URL"
+
+Bạn gõ `http://user:pass@proxy.com` vào ô Proxy address.
+**Sửa:** ô Proxy address chỉ ghi `http://proxy.com`. Tài khoản → ô Username. Mật khẩu → ô Password.
+
+### ❌ "Proxy username and password must be configured together"
+
+Bạn điền Username mà quên Password (hoặc ngược lại).
+**Sửa:** điền cả hai, hoặc xóa trắng cả hai.
+
+### ❌ "SOCKS5 proxy authentication is not supported by Patchright"
+
+Bạn nhập tài khoản/mật khẩu cho proxy loại SOCKS.
+**Sửa:** đổi sang proxy `http://` / `https://`, hoặc xóa Username + Password nếu proxy SOCKS của bạn không cần đăng nhập.
+
+### ❌ "Unsupported proxy protocol"
+
+Bạn gõ sai tiền tố, ví dụ `ftp://` hoặc `socks://` (thiếu số).
+**Sửa:** chỉ dùng đúng 4 tiền tố: `http://`, `https://`, `socks4://`, `socks5://`.
+
+### ❌ "Cannot change a proxy while a bot run is active"
+
+Tool đang chạy thì không cho sửa proxy — vì sửa giữa chừng sẽ làm hỏng phiên đang chạy.
+**Sửa:** bấm **Stop**, đợi tool dừng hẳn, rồi sửa.
+
+### ❌ Lưu thành công nhưng chạy tool vẫn lỗi mạng
+
+Nguyên nhân theo thứ tự khả năng:
+
+1. **Proxy chết.** Kiểm tra bằng mục 7. Proxy miễn phí/rẻ thường chết liên tục.
+2. **Công tắc "Use for API requests too" đang BẬT** và proxy chặn API. → Tắt đi.
+3. **Proxy đã hết hạn dung lượng.** Nhiều gói bán theo GB; hết GB là proxy ngừng chạy dù thông tin vẫn đúng. → Vào trang nhà cung cấp kiểm tra.
+4. **Chưa chạy lại tool.** Thay đổi chỉ áp dụng cho **lần chạy tới**.
+
+### ❌ Tool chạy chậm hẳn sau khi thêm proxy
+
+Bình thường. Proxy ở nước ngoài làm mọi request chậm hơn.
+**Sửa:** chọn proxy **gần Việt Nam** (Singapore, Hong Kong) thay vì Mỹ/Âu.
+
+---
+
+## 9. Cấu hình đề xuất cho người mới
+
+Nếu bạn có **4 tài khoản**, đây là cấu hình an toàn và thực tế nhất:
+
+| Tài khoản   | Proxy                 | "Use for API requests too" |
+| ----------- | --------------------- | -------------------------- |
+| Tài khoản 1 | Proxy riêng #1 (http) | TẮT                        |
+| Tài khoản 2 | Proxy riêng #2 (http) | TẮT                        |
+| Tài khoản 3 | Proxy riêng #3 (http) | TẮT                        |
+| Tài khoản 4 | Proxy riêng #4 (http) | TẮT                        |
+
+**Lý do chọn cấu hình này:**
+
+- **HTTP thay vì SOCKS** → dùng được mật khẩu, không vướng giới hạn của Patchright.
+- **Công tắc TẮT** → tránh được nhóm lỗi API phổ biến nhất, vẫn che được trình duyệt (phần Microsoft soi kỹ nhất).
+- **Proxy riêng từng tài khoản** → mỗi tài khoản một IP, đúng nguyên tắc vàng ở mục 6.
+
+Chạy thử vài ngày. Nếu ổn định và bạn muốn che chắn thêm, hãy thử bật công tắc cho **một** tài khoản trước, quan sát log — đừng bật hết cùng lúc, vì nếu có lỗi bạn sẽ không biết tại proxy nào.
+
+---
+
+## 10. Bảng tra nhanh
+
+| Việc cần làm                 | Ở đâu                                                  |
+| ---------------------------- | ------------------------------------------------------ |
+| Mở khung sửa proxy           | Nút **Proxy** trên dòng tài khoản                      |
+| Nhập proxy                   | Ô **Proxy address** — nhớ có `http://`                 |
+| Nhập cổng                    | Ô **Port** — số 1–65535                                |
+| Nhập tài khoản proxy         | Ô **Username**                                         |
+| Nhập mật khẩu proxy          | Ô **Password**                                         |
+| Cho proxy che cả API         | Công tắc **Use for API requests too** (khuyên **TẮT**) |
+| Lưu                          | Nút **Save Proxy**                                     |
+| Xóa proxy                    | Nút **Remove Proxy**                                   |
+| Kiểm tra proxy sống hay chết | `https://whatismyipaddress.com` (mục 7)                |
+| Proxy lưu ở đâu              | File `.env`, dòng `ACCOUNT_N_PROXY_*`                  |
+
+> 🔒 **Lưu bảo mật:** mật khẩu proxy được lưu trong file `.env` trên máy bạn. Web UI **không bao giờ hiển thị lại** mật khẩu đã lưu — đó là lý do ô Password luôn trống khi bạn mở lại khung sửa. Muốn giữ nguyên mật khẩu cũ, **cứ để trống ô đó rồi bấm Save** — tool sẽ giữ lại mật khẩu đang có.
+
+---
+
+**Xem thêm:** `WEB_UI_GUIDE.vi.md` — hướng dẫn đầy đủ về Web UI dành cho người mới bắt đầu.
diff --git a/WEB_UI_GUIDE.md b/WEB_UI_GUIDE.md
new file mode 100644
index 00000000..38d636bc
--- /dev/null
+++ b/WEB_UI_GUIDE.md
@@ -0,0 +1,637 @@
+# Microsoft Rewards Script - Complete Beginner's Guide
+
+A start-to-finish guide to installing and using this tool through its new **Web UI**. No coding experience needed. Every command is something you copy, paste, and press Enter on.
+
+---
+
+## Table of Contents
+
+1. [What this tool actually does](#1-what-this-tool-actually-does)
+2. [Prerequisites and system requirements](#2-prerequisites-and-system-requirements)
+3. [Environment setup (one time only)](#3-environment-setup-one-time-only)
+4. [Starting the Web UI](#4-starting-the-web-ui)
+5. [How to use the Web UI](#5-how-to-use-the-web-ui)
+6. [Optional: turning on scheduling](#6-optional-turning-on-scheduling)
+7. [Troubleshooting](#7-troubleshooting)
+8. [Safety and privacy notes](#8-safety-and-privacy-notes)
+
+---
+
+## 1. What this tool actually does
+
+Think of it as **a robot that uses a web browser for you**.
+
+You normally earn Microsoft Rewards points by searching on Bing, clicking daily
+cards, and reading articles. This tool opens a real browser, signs in as you,
+and does that clicking and searching itself.
+
+There are three pieces. It helps to picture them like a restaurant:
+
+| Piece          | Restaurant analogy | What it really is                                       |
+| -------------- | ------------------ | ------------------------------------------------------- |
+| **The bot**    | The chef           | The part that opens browsers and collects points        |
+| **The server** | The waiter         | A small program that takes your orders and reports back |
+| **The Web UI** | The menu           | The page you click on in your browser                   |
+
+You will mostly only touch **the menu** (the Web UI). But the waiter has to be
+awake for the menu to work, which is why you will start the server in Step 4 and
+leave it running.
+
+---
+
+## 2. Prerequisites and system requirements
+
+### What your computer needs
+
+- **Windows, macOS, or Linux.** Any of them is fine.
+- **About 2 GB of free disk space.** The tool downloads its own private copy of
+  a browser, which is most of that.
+- **An internet connection.**
+- **A screen.** For your very first sign-in you need to see a browser window, so
+  this doesn't work on a screen-less server for that one step.
+
+### What you need to have ready
+
+- **A Microsoft account** that already has Rewards enabled. Sign in at
+  [rewards.bing.com](https://rewards.bing.com) once in your normal browser and
+  make sure it works before automating it.
+- **Your account's email address.**
+- **Your password** _only if_ your account signs in with a password. If you use
+  the Microsoft Authenticator app with no password, you can skip it.
+- **20 to 30 minutes** for the one-time setup. Most of that is waiting for
+  downloads.
+
+### Software you will install
+
+Just one thing: **Node.js**, version 24 or newer. Step 3 walks you through it.
+
+Node.js is the engine this tool runs on. Nothing about it requires you to write
+code, the same way driving a car doesn't require you to build an engine.
+
+> **A note on comfort level:** you will be typing commands into a black window
+> (the "terminal"). That is normal and expected. You are not programming. You are
+> giving short instructions, like typing a web address into a browser.
+
+---
+
+## 3. Environment setup (one time only)
+
+Do these five steps in order. Each one builds on the last.
+
+### Step 3.1 - Install Node.js
+
+**On Windows:**
+
+1. Go to **[nodejs.org](https://nodejs.org)**.
+2. Download the **LTS** version (the big green button). Make sure the version
+   number starts with **24** or higher.
+3. Open the downloaded file and click **Next** through the installer. The default
+   options are correct, do not change anything.
+4. When it finishes, restart your computer. This matters. Windows needs a restart
+   to notice that Node.js exists.
+
+**On macOS:** download the LTS `.pkg` installer from
+[nodejs.org](https://nodejs.org) and run it.
+
+**On Linux:** use [nodesource](https://github.com/nodesource/distributions) or
+your package manager, and confirm you get version 24 or newer.
+
+**Check that it worked.** Open a terminal:
+
+- **Windows:** press the **Windows key**, type `powershell`, press Enter.
+- **macOS:** press **Cmd+Space**, type `terminal`, press Enter.
+- **Linux:** press **Ctrl+Alt+T**.
+
+Type this and press Enter:
+
+```bash
+node --version
+```
+
+You should see something like `v24.5.0`. If you see "command not found", Node.js
+did not install correctly, or you skipped the restart.
+
+> **If the number is lower than 24**, you have an old Node.js. Install the new
+> one over it using the steps above.
+
+### Step 3.2 - Get the tool onto your computer
+
+**The easy way (no Git needed):**
+
+1. Go to the project's GitHub page.
+2. Click the green **Code** button, then **Download ZIP**.
+3. Right-click the downloaded ZIP and choose **Extract All**.
+4. Move the extracted folder somewhere you'll remember, like your Documents
+   folder.
+
+> **Avoid folders synced by OneDrive, Dropbox, or Google Drive if you can.**
+> They sometimes lock files while the tool is writing to them, which causes
+> confusing errors.
+
+### Step 3.3 - Point your terminal at the folder
+
+Your terminal needs to be "inside" the project folder, the way File Explorer is
+inside a folder when you double-click it.
+
+**The easiest method on Windows:**
+
+1. Open the project folder in File Explorer.
+2. Click the address bar at the top (where the folder path is shown).
+3. Type `powershell` and press Enter.
+
+A terminal opens already pointed at the right place.
+
+**Any platform:** type `cd ` (with a space), then drag the folder from your file
+manager onto the terminal window, then press Enter.
+
+**Check that you're in the right place:**
+
+```bash
+ls
+```
+
+You should see file names including `package.json` and `config.example.json`. If
+you don't, you're in the wrong folder.
+
+> **Keep this terminal open.** Every command from here on gets typed into it.
+
+### Step 3.4 - Install the tool's parts
+
+Type this and press Enter:
+
+```bash
+npm run pre-build
+```
+
+**This takes a while.** Five to fifteen minutes is normal. It is downloading the
+tool's private browser, which is a few hundred megabytes.
+
+You will see a lot of scrolling text. That's fine. Warnings in yellow are
+normal and safe to ignore. Only stop and worry if it ends with the word `error`
+and nothing else happens.
+
+Then run:
+
+```bash
+npm run build
+```
+
+This one is quick, usually under a minute. It converts the project's source
+files into the form the computer actually runs.
+
+> **Remember this command.** Any time you change the project's files, you run
+> `npm run build` again to apply the change.
+
+### Step 3.5 - Create your two settings files
+
+The project ships **example** settings files. You make your own copies and fill
+them in. The examples are templates, like a blank form.
+
+**File 1: `config.json`** - controls how the bot behaves.
+
+Find the file named `config.example.json` in the project folder. **Copy** it, and
+rename the copy to exactly `config.json`.
+
+- Windows: right-click → Copy, right-click → Paste, then rename
+  `config.example - Copy.json` to `config.json`.
+- Make sure the name is exactly `config.json`, with no "example" and no "copy".
+
+You do not need to edit anything inside it. The defaults are fine.
+
+**File 2: `.env`** - holds your account email and password.
+
+Find the file named `env.example`. Copy it and rename the copy to exactly
+`.env` - starting with a dot, and with **no** file extension.
+
+> **Windows tip:** Explorer may refuse to let you name a file starting with a
+> dot. Work around it by naming it `.env.` **with a trailing dot** - Windows
+> strips that automatically and leaves you with `.env`.
+
+Now open `.env` in **Notepad** (right-click → Open with → Notepad). You'll see
+lines like this:
+
+```env
+ACCOUNT_1_EMAIL=email@example.com
+#ACCOUNT_1_PASSWORD=your_password
+```
+
+Change the email to your real one. If your account uses a password, delete the
+`#` at the start of the password line and put your real password in:
+
+```env
+ACCOUNT_1_EMAIL=your.real.email@outlook.com
+ACCOUNT_1_PASSWORD=YourRealPassword
+```
+
+**The `#` means "ignore this line."** Removing it switches the line on.
+
+If your account uses the Authenticator app instead of a password, leave the
+password line alone with its `#`. The tool handles that.
+
+Save the file and close Notepad.
+
+> **If you use two-factor authentication**, there's a line for
+> `ACCOUNT_1_TOTP_SECRET`. Filling it in lets the tool generate your 6-digit
+> codes automatically. To get the value: in your Microsoft security settings,
+> open "Manage how you sign in", add an authenticator app, and when the QR code
+> appears choose **"enter code manually"**. Paste that code as the value.
+
+**Setup is done.** You never have to repeat Steps 3.1 through 3.5.
+
+---
+
+## 4. Starting the Web UI
+
+Two steps: wake up the server, then open the page.
+
+### Step 4.1 - Start the server
+
+In your terminal (still inside the project folder), run:
+
+```bash
+npm run api
+```
+
+You'll see a few lines of startup text and then the terminal will appear to
+**hang**, showing no new output and no prompt.
+
+**That is correct.** The server is now running and listening. It's supposed to
+sit there. The terminal is not frozen.
+
+> **Leave this terminal window open and do not close it.** Closing it turns the
+> server off, and the Web UI stops working. Minimize it instead.
+
+### Step 4.2 - Open the page
+
+Open your normal web browser (Chrome, Edge, Firefox, whatever you use) and go to:
+
+```
+http://127.0.0.1:3010
+```
+
+`127.0.0.1` always means "this computer." You're not visiting the internet, just
+your own machine.
+
+You should see the **Microsoft Rewards Control** dashboard.
+
+Look at the top right. There's a **Server** badge:
+
+| Badge       | Meaning                                                     |
+| ----------- | ----------------------------------------------------------- |
+| **Online**  | Server is awake, nothing running. This is what you want.    |
+| **Running** | A run is in progress right now.                             |
+| **Offline** | The page can't reach the server. Check Step 4.1's terminal. |
+
+If it says Offline, your server terminal is probably closed or errored out.
+
+### Every time after today
+
+Starting the tool is just those two steps:
+
+1. Open a terminal in the project folder, run `npm run api`
+2. Open `http://127.0.0.1:3010`
+
+---
+
+## 5. How to use the Web UI
+
+The page is a single column of sections, top to bottom. Here's each one.
+
+### 5.1 - Add Account
+
+The box at the top. Type an email address and click **Add Account**.
+
+This writes the email into your `.env` file for you, so you don't have to edit
+that file by hand again. The account appears in the list immediately.
+
+> **Important: the UI never asks for your password, on purpose.** Passwords only
+> ever live in your `.env` file on your own disk. If the account you just added
+> needs a password, open `.env` in Notepad and add a matching line. For an
+> account added as `ACCOUNT_2`, the line is `ACCOUNT_2_PASSWORD=yourpassword`.
+
+### 5.2 - Account Overview
+
+Four counters showing the health of your accounts.
+
+| Counter            | What it means                                                   |
+| ------------------ | --------------------------------------------------------------- |
+| **Total Accounts** | How many accounts the tool knows about                          |
+| **Logged In**      | Has a valid saved sign-in. Ready to run.                        |
+| **Not Logged In**  | Has never signed in. Needs the step below.                      |
+| **Login Expired**  | Was signed in, but the saved sign-in went stale. Sign in again. |
+
+**A brand new account starts as "Not Logged In." That's expected.**
+
+### 5.3 - First sign-in for a new account
+
+Microsoft will not let a robot get through a fresh sign-in cleanly, so you do
+the first one yourself. Once. It gets saved after that.
+
+Open a **second** terminal in the project folder (leave the server one alone)
+and run this, with your own email:
+
+```bash
+npm run manual-login -- --email your.real.email@outlook.com
+```
+
+A browser window opens. Sign in normally, exactly like any other day, including
+any 2FA prompt. When you land on the Rewards page, **wait about five seconds**.
+The window closes by itself and your sign-in is saved.
+
+Back on the dashboard, that account flips to **Logged In** within a few seconds.
+
+> Do this again whenever an account shows **Login Expired**. It's the standard
+> fix for almost every sign-in problem.
+
+### 5.4 - Execution Settings
+
+Four controls that decide _how_ the next run behaves. **Set these before you
+press Run.** Your choices are remembered in your browser for next time.
+
+**Run in Headless Mode**
+
+- **Off** (default): you see the browser windows open and click around.
+- **On**: everything happens invisibly in the background.
+
+Off is better while you're learning, because you can see what's happening. On is
+better once you trust it, so windows don't steal focus while you work.
+
+> Don't use headless for a first sign-in. Use `manual-login` from Section 5.3.
+
+**Run Visual Search**
+
+Off by default. Turn it on to also do Bing Visual Search tasks (the ones where
+you search using a picture instead of words) for extra daily points.
+
+**Run 30-Minute Edge Browsing**
+
+Off by default. Turn it on to complete the Edge browsing reward, where the tool
+browses in the background for half an hour.
+
+> **This makes the run take at least 30 minutes longer.** That's the reward's
+> own requirement, not the tool being slow. It's marked experimental because
+> Microsoft changes how it works from time to time.
+
+**Schedule for Later**
+
+A date and time picker. Leave it **empty** to run right now. Fill it in only if
+you're using the Schedule Run button (see Section 5.7).
+
+### 5.5 - Ready to Execute
+
+Your account list, plus the action buttons.
+
+Each account row shows a **checkbox**, the **email**, how many **runs** it has
+done, when it **last** ran, its **points**, and a **status badge**.
+
+**How to run:**
+
+1. **Tick the checkbox** on each account you want to run. Or click **Select All**
+   to tick everything (it turns into **Deselect All**).
+2. Double-check your toggles in Execution Settings.
+3. Click **Run Selected**.
+
+A small message slides in confirming the start, the Server badge flips to
+**Running**, and log lines start appearing at the bottom of the page.
+
+**What to expect:** a full run takes a while, commonly 20 to 60 minutes per
+account, longer with Edge Browsing on. The tool deliberately pauses between
+actions so it behaves like a person rather than a machine. Slow is intentional.
+
+**The Stop button** is greyed out unless something is actually running. Click it
+to end the run: it asks the bot to shut its browsers down cleanly, and if the bot
+doesn't respond in time the server force-closes it. No orphaned browser windows
+left behind either way.
+
+**The Remove button** takes an account off this list, but it **does not delete it
+from your `.env` file**, so it will reappear on the next refresh. To remove an
+account for good, open `.env` in Notepad and delete its `ACCOUNT_N_EMAIL` line.
+
+### 5.6 - Per-account proxy
+
+Every account row has a **Proxy** button. Click it to open the proxy editor just
+below the account list.
+
+The editor takes a **Proxy address**, **Port**, **Username**, **Password**, and a
+**Use for API requests too** toggle. After saving, the account row shows a small
+blue `host:port` badge so you can see at a glance which accounts have a proxy.
+
+**You only need this section if you run more than one account.** With a single
+account, skip it — adding a proxy just makes the tool slower.
+
+> 📖 **What a proxy is, which kind to buy, where to get one, and how to fix the
+> common errors** — see the dedicated guide: **`PROXY_GUIDE.vi.md`** (Vietnamese).
+> It is written for someone who has never used a proxy before.
+
+**Four things worth knowing right away:**
+
+- **One account, one proxy.** Several accounts sharing a single proxy defeats the
+  purpose entirely — Microsoft still sees them all on the same IP.
+- **Put proxy credentials in their own fields**, never inside the Proxy address box.
+- **SOCKS proxies cannot use a password.** Use HTTP or HTTPS if your proxy needs
+  a login.
+- **Changes apply to the next run.** You cannot edit a proxy while a run is
+  active — press **Stop** first.
+
+### 5.7 - Scheduled Tasks
+
+Lists runs you've queued for a future time. Each entry shows the time, which
+accounts, and a **Cancel** button.
+
+### 5.8 - How to schedule a run
+
+1. Tick the accounts you want.
+2. Set the date and time in **Schedule for Later**. It must be in the future,
+   and it's your computer's local clock.
+3. Click **Schedule Run**.
+
+**Two things have to be true for a scheduled run to actually fire:**
+
+- Scheduling must be switched on. It's **off by default** as a safety measure.
+  See [Section 6](#6-optional-turning-on-scheduling). If it's off, you'll get an
+  error message mentioning `API_ALLOW_SCHEDULE_WRITE`.
+- **Your server terminal must still be running when the time arrives**, and your
+  computer must be awake. Nothing can start a run if the waiter has gone home.
+
+### 5.9 - Live Logs
+
+The black console at the bottom. This is the bot narrating what it's doing, live.
+
+Each line has a timestamp, a level, and a message. The level is the useful part:
+
+| Level     | Colour | What it means                                       |
+| --------- | ------ | --------------------------------------------------- |
+| **INFO**  | Normal | Routine progress. Ignore these.                     |
+| **WARN**  | Yellow | Something was skipped or retried. Usually harmless. |
+| **ERROR** | Red    | Something actually failed. Worth reading.           |
+
+**Auto-scroll** (on by default) keeps the newest line in view. Turn it off when
+you want to scroll up and read something without being yanked back down.
+
+**Clear** empties the display. It only clears your view, not the server's
+records, so reloading the page brings recent history back.
+
+The console keeps the most recent 500 lines and replays the last 100 when you
+open the page, so you don't come back to a blank screen.
+
+**When something goes wrong, this is the first place to look.** Scroll to the
+red lines and read the message.
+
+---
+
+## 6. Optional: turning on scheduling
+
+Scheduling is disabled by default so that nothing can queue up runs on your
+machine without you deliberately allowing it. Turning it on is a one-line
+change.
+
+1. Stop the server: click its terminal window and press **Ctrl+C**.
+2. Open your `.env` file in Notepad.
+3. Add this line at the bottom:
+
+```env
+API_ALLOW_SCHEDULE_WRITE=true
+```
+
+4. Save and close.
+5. Start the server again with `npm run api`.
+
+**Schedule Run** now works.
+
+---
+
+## 7. Troubleshooting
+
+### The page says "Offline"
+
+The server isn't running or isn't reachable.
+
+- Check the terminal where you ran `npm run api`. Still open? Any red text?
+- If it's closed, run `npm run api` again.
+- Confirm the address is exactly `http://127.0.0.1:3010`.
+
+### "Port 3010 is already in use"
+
+A server is already running, probably from earlier. Either use the one that's
+already up (just open the page), or close the other terminal window and try
+again.
+
+### An account is stuck on "Not Logged In" or "Login Expired"
+
+Run the manual sign-in from Section 5.3. This fixes the large majority of
+sign-in problems.
+
+```bash
+npm run manual-login -- --email your.real.email@outlook.com
+```
+
+If it keeps expiring, delete the saved sessions and start clean:
+
+```bash
+npm run clear-sessions -- email your.real.email@outlook.com
+```
+
+Then sign in manually again.
+
+### "No accounts configured in .env yet"
+
+The email is in your browser's list but not in the `.env` file. Add it again
+through the **Add Account** box, which writes the file for you.
+
+### Run Selected does nothing
+
+- Did you tick at least one checkbox? Selecting accounts is separate from
+  running them.
+- Is the badge showing **Running**? Only one run happens at a time, so the
+  button is disabled while one is in progress.
+
+### Visual Search or Edge Browsing didn't happen
+
+Confirm the toggle was **on before** you clicked Run Selected, not after. Then
+check the Live Logs for a line like:
+
+```
+[Config] override: CONFIG_WORKER_VISUAL_SEARCH -> .workers.doVisualSearch = true
+```
+
+That line is the tool confirming it received your toggle. If it's there, the
+feature was switched on for that run. If a feature still gets skipped after
+that, the log will say why just below it, usually that the account had no such
+task available that day.
+
+### A command failed with lots of red text
+
+Try, in order:
+
+1. `npm run build` and then retry.
+2. If that fails, `npm run pre-build` followed by `npm run build`.
+3. Check that `config.json` and `.env` both exist and are named exactly right. A
+   missing `config.json` is one of the most common causes.
+
+### Browser windows were left open after a crash
+
+On Windows:
+
+```bash
+npm run kill-chrome-win
+```
+
+---
+
+## 8. Safety and privacy notes
+
+**Your credentials stay on your machine.** Passwords live only in your `.env`
+file on your own disk. The Web UI never asks for them, never displays them, and
+never sends them anywhere. Never share your `.env` file, and never post it in a
+screenshot or a support thread.
+
+**The dashboard has no password on it by default.** It's bound to `127.0.0.1`,
+which means only programs on your own computer can reach it. Anyone else on your
+Wi-Fi cannot. That's a deliberate default.
+
+If you ever change the server to listen on your network (with something like
+`--host 0.0.0.0`), **set a token first**, or anyone on that network can start
+runs on your accounts. Add a line like `API_TOKEN=some-long-random-string` to
+your `.env` before doing that.
+
+**Don't put `.env` or `config.json` into a public GitHub repository.** The
+project already tells Git to ignore both, so this only happens if you go out of
+your way. Just don't.
+
+**About the risk to your account.** Automating Microsoft Rewards is against
+Microsoft's terms of service. Accounts do get suspended or banned for it. This
+tool tries to behave like a person, with realistic delays, but there is no
+guarantee. Use it on an account you can afford to lose, and understand you're
+accepting that risk yourself.
+
+---
+
+## Quick reference
+
+**Daily startup:**
+
+```bash
+npm run api
+```
+
+Then open `http://127.0.0.1:3010`.
+
+**Common commands:**
+
+| Command                                           | What it does                           |
+| ------------------------------------------------- | -------------------------------------- |
+| `npm run api`                                     | Starts the server for the Web UI       |
+| `npm run build`                                   | Applies changes you've made to files   |
+| `npm run manual-login -- --email you@example.com` | Signs an account in by hand            |
+| `npm run clear-sessions -- list`                  | Shows saved sign-ins                   |
+| `npm run clear-sessions -- email you@example.com` | Deletes one account's saved sign-in    |
+| `npm run kill-chrome-win`                         | Closes stuck browser windows (Windows) |
+
+**Key files:**
+
+| File          | Holds                                      |
+| ------------- | ------------------------------------------ |
+| `.env`        | Your emails, passwords, and server options |
+| `config.json` | How the bot behaves                        |
+
+**Keyboard:** **Ctrl+C** in the server terminal stops the server.
diff --git a/WEB_UI_GUIDE.vi.md b/WEB_UI_GUIDE.vi.md
new file mode 100644
index 00000000..277eb1fb
--- /dev/null
+++ b/WEB_UI_GUIDE.vi.md
@@ -0,0 +1,530 @@
+# Microsoft Rewards Script - Hướng dẫn đầy đủ cho người mới bắt đầu
+
+Hướng dẫn từ đầu đến cuối cách cài đặt và sử dụng công cụ này thông qua **Web UI** mới. Không cần biết lập trình. Mọi lệnh đều chỉ cần sao chép, dán và nhấn Enter.
+
+> **Lưu ý:** các nút và tên mục trong giao diện vẫn giữ nguyên tiếng Anh (ví dụ **Run Selected**), vì Web UI chưa được dịch. Lệnh, tên file và tên biến cũng giữ nguyên tiếng Anh.
+
+---
+
+## Mục lục
+
+1. [Công cụ này thực sự làm gì](#1-công-cụ-này-thực-sự-làm-gì)
+2. [Yêu cầu trước khi bắt đầu](#2-yêu-cầu-trước-khi-bắt-đầu)
+3. [Cài đặt môi trường (chỉ làm một lần)](#3-cài-đặt-môi-trường-chỉ-làm-một-lần)
+4. [Khởi động Web UI](#4-khởi-động-web-ui)
+5. [Cách sử dụng Web UI](#5-cách-sử-dụng-web-ui)
+6. [Tùy chọn: bật tính năng lên lịch](#6-tùy-chọn-bật-tính-năng-lên-lịch)
+7. [Xử lý sự cố](#7-xử-lý-sự-cố)
+8. [Lưu ý về an toàn và bảo mật](#8-lưu-ý-về-an-toàn-và-bảo-mật)
+9. [Tra cứu nhanh](#tra-cứu-nhanh)
+
+---
+
+## 1. Công cụ này thực sự làm gì
+
+Hãy hình dung nó như **một con robot dùng trình duyệt web thay cho bạn**.
+
+Bình thường bạn kiếm điểm Microsoft Rewards bằng cách tìm kiếm trên Bing, bấm vào các thẻ nhiệm vụ hằng ngày và đọc bài viết. Công cụ này sẽ mở một trình duyệt thật, đăng nhập bằng tài khoản của bạn, rồi tự bấm và tự tìm kiếm.
+
+Có ba phần. Hình dung chúng như một nhà hàng sẽ dễ hiểu hơn:
+
+| Phần       | Ví von nhà hàng | Thực chất là gì                                       |
+| ---------- | --------------- | ----------------------------------------------------- |
+| **Bot**    | Đầu bếp         | Phần mở trình duyệt và thu thập điểm                  |
+| **Server** | Người phục vụ   | Chương trình nhỏ nhận lệnh của bạn và báo lại kết quả |
+| **Web UI** | Thực đơn        | Trang web bạn bấm vào trong trình duyệt               |
+
+Bạn gần như chỉ cần đụng tới **thực đơn** (Web UI). Nhưng người phục vụ phải đang làm việc thì thực đơn mới có tác dụng, vì vậy ở bước 4 bạn sẽ khởi động server và để nó chạy suốt.
+
+---
+
+## 2. Yêu cầu trước khi bắt đầu
+
+### Máy tính của bạn cần có
+
+- **Windows, macOS hoặc Linux.** Hệ điều hành nào cũng được.
+- **Khoảng 2 GB dung lượng trống.** Công cụ sẽ tải về một bản trình duyệt riêng của nó, chiếm phần lớn dung lượng này.
+- **Kết nối internet.**
+- **Một màn hình.** Lần đăng nhập đầu tiên bạn cần nhìn thấy cửa sổ trình duyệt, nên bước đó không chạy được trên máy chủ không có màn hình.
+
+### Bạn cần chuẩn bị sẵn
+
+- **Một tài khoản Microsoft** đã bật Rewards. Hãy đăng nhập thử tại [rewards.bing.com](https://rewards.bing.com) một lần bằng trình duyệt thường ngày và chắc chắn nó hoạt động trước khi tự động hóa.
+- **Địa chỉ email của tài khoản.**
+- **Mật khẩu**, _chỉ khi_ tài khoản của bạn đăng nhập bằng mật khẩu. Nếu bạn dùng ứng dụng Microsoft Authenticator và không có mật khẩu thì bỏ qua.
+- **20 đến 30 phút** cho việc cài đặt một lần. Phần lớn thời gian là chờ tải xuống.
+
+### Phần mềm cần cài
+
+Chỉ một thứ duy nhất: **Node.js**, phiên bản 24 trở lên. Bước 3 sẽ hướng dẫn chi tiết.
+
+Node.js là bộ máy chạy công cụ này. Bạn không cần viết bất kỳ dòng code nào, giống như lái xe không đòi hỏi bạn phải tự chế tạo động cơ.
+
+> **Một lời trấn an:** bạn sẽ gõ lệnh vào một cửa sổ màu đen (gọi là "terminal"). Chuyện này hoàn toàn bình thường. Bạn không hề lập trình. Bạn chỉ đang đưa ra vài chỉ dẫn ngắn, giống như gõ địa chỉ trang web vào trình duyệt.
+
+---
+
+## 3. Cài đặt môi trường (chỉ làm một lần)
+
+Làm lần lượt năm bước sau. Mỗi bước dựa trên bước trước.
+
+### Bước 3.1 - Cài Node.js
+
+**Trên Windows:**
+
+1. Vào **[nodejs.org](https://nodejs.org)**.
+2. Tải bản **LTS** (nút màu xanh lớn). Kiểm tra số phiên bản bắt đầu bằng **24** hoặc cao hơn.
+3. Mở file vừa tải và bấm **Next** xuyên suốt trình cài đặt. Các lựa chọn mặc định là đúng, đừng thay đổi gì cả.
+4. Cài xong thì khởi động lại máy. Bước này quan trọng: Windows cần khởi động lại mới nhận ra Node.js.
+
+**Trên macOS:** tải file cài đặt `.pkg` bản LTS từ [nodejs.org](https://nodejs.org) và chạy nó.
+
+**Trên Linux:** dùng [nodesource](https://github.com/nodesource/distributions) hoặc trình quản lý gói của hệ thống, và xác nhận bạn có phiên bản 24 trở lên.
+
+**Kiểm tra đã cài thành công.** Mở terminal:
+
+- **Windows:** nhấn **phím Windows**, gõ `powershell`, nhấn Enter.
+- **macOS:** nhấn **Cmd+Space**, gõ `terminal`, nhấn Enter.
+- **Linux:** nhấn **Ctrl+Alt+T**.
+
+Gõ lệnh này và nhấn Enter:
+
+```bash
+node --version
+```
+
+Bạn sẽ thấy kết quả dạng `v24.5.0`. Nếu thấy "command not found" thì Node.js chưa cài đúng, hoặc bạn đã bỏ qua bước khởi động lại.
+
+> **Nếu số phiên bản nhỏ hơn 24**, nghĩa là máy đang có Node.js cũ. Hãy cài bản mới đè lên theo các bước ở trên.
+
+### Bước 3.2 - Tải công cụ về máy
+
+**Cách đơn giản nhất (không cần Git):**
+
+1. Vào trang GitHub của dự án.
+2. Bấm nút **Code** màu xanh, rồi chọn **Download ZIP**.
+3. Chuột phải vào file ZIP vừa tải, chọn **Extract All**.
+4. Di chuyển thư mục đã giải nén tới nơi bạn dễ nhớ, ví dụ thư mục Documents.
+
+> **Nên tránh các thư mục được đồng bộ bởi OneDrive, Dropbox hoặc Google Drive.** Chúng đôi khi khóa file trong lúc công cụ đang ghi vào, gây ra những lỗi rất khó hiểu.
+
+### Bước 3.3 - Đưa terminal vào đúng thư mục
+
+Terminal cần phải "đứng bên trong" thư mục dự án, giống như cách File Explorer mở một thư mục khi bạn bấm đúp vào nó.
+
+**Cách dễ nhất trên Windows:**
+
+1. Mở thư mục dự án trong File Explorer.
+2. Bấm vào thanh địa chỉ ở trên cùng (nơi hiện đường dẫn thư mục).
+3. Gõ `powershell` và nhấn Enter.
+
+Một terminal sẽ mở ra, đã nằm sẵn đúng vị trí.
+
+**Mọi hệ điều hành:** gõ `cd ` (có dấu cách), rồi kéo thư mục từ trình quản lý file thả vào cửa sổ terminal, sau đó nhấn Enter.
+
+**Kiểm tra bạn đang đứng đúng chỗ:**
+
+```bash
+ls
+```
+
+Bạn phải thấy các tên file, trong đó có `package.json` và `config.example.json`. Nếu không thấy thì bạn đang ở sai thư mục.
+
+> **Giữ nguyên cửa sổ terminal này.** Mọi lệnh từ đây về sau đều gõ vào đó.
+
+### Bước 3.4 - Cài các thành phần của công cụ
+
+Gõ lệnh này và nhấn Enter:
+
+```bash
+npm run pre-build
+```
+
+**Lệnh này chạy khá lâu.** Từ năm đến mười lăm phút là bình thường. Nó đang tải trình duyệt riêng của công cụ, dung lượng vài trăm megabyte.
+
+Bạn sẽ thấy rất nhiều chữ chạy trên màn hình. Điều đó không sao cả. Các cảnh báo màu vàng là bình thường và có thể bỏ qua. Chỉ cần lo khi nó kết thúc bằng chữ `error` và không có gì xảy ra tiếp.
+
+Sau đó chạy:
+
+```bash
+npm run build
+```
+
+Lệnh này nhanh, thường chưa tới một phút. Nó chuyển các file mã nguồn của dự án sang dạng mà máy tính thực sự chạy được.
+
+> **Hãy nhớ lệnh này.** Bất cứ khi nào bạn thay đổi file trong dự án, chạy lại `npm run build` để áp dụng thay đổi.
+
+### Bước 3.5 - Tạo hai file cấu hình
+
+Dự án đi kèm các file cấu hình **mẫu**. Bạn tạo bản sao của riêng mình rồi điền thông tin vào. Các file mẫu giống như một tờ đơn trống.
+
+**File 1: `config.json`** - điều khiển cách bot hoạt động.
+
+Tìm file tên `config.example.json` trong thư mục dự án. **Sao chép** nó, rồi đổi tên bản sao thành đúng `config.json`.
+
+- Windows: chuột phải → Copy, chuột phải → Paste, sau đó đổi tên `config.example - Copy.json` thành `config.json`.
+- Hãy chắc chắn tên file đúng là `config.json`, không còn chữ "example" hay "copy".
+
+Bạn không cần sửa gì bên trong file này. Các giá trị mặc định là đủ dùng.
+
+**File 2: `.env`** - chứa email và mật khẩu tài khoản của bạn.
+
+Tìm file tên `env.example`. Sao chép nó và đổi tên bản sao thành đúng `.env` - bắt đầu bằng một dấu chấm, và **không có** đuôi mở rộng.
+
+> **Mẹo cho Windows:** Explorer có thể không cho bạn đặt tên file bắt đầu bằng dấu chấm. Cách lách: đặt tên là `.env.` **có dấu chấm ở cuối** - Windows sẽ tự bỏ dấu chấm đó và để lại đúng `.env`.
+
+Bây giờ mở `.env` bằng **Notepad** (chuột phải → Open with → Notepad). Bạn sẽ thấy các dòng như thế này:
+
+```env
+ACCOUNT_1_EMAIL=email@example.com
+#ACCOUNT_1_PASSWORD=your_password
+```
+
+Đổi email thành email thật của bạn. Nếu tài khoản dùng mật khẩu, xóa dấu `#` ở đầu dòng mật khẩu và điền mật khẩu thật vào:
+
+```env
+ACCOUNT_1_EMAIL=your.real.email@outlook.com
+ACCOUNT_1_PASSWORD=YourRealPassword
+```
+
+**Dấu `#` nghĩa là "bỏ qua dòng này."** Xóa nó đi là bật dòng đó lên.
+
+Nếu tài khoản của bạn dùng ứng dụng Authenticator thay vì mật khẩu, cứ để nguyên dòng mật khẩu cùng dấu `#`. Công cụ sẽ tự xử lý.
+
+Lưu file và đóng Notepad.
+
+> **Nếu bạn dùng xác thực hai lớp**, có một dòng dành cho `ACCOUNT_1_TOTP_SECRET`. Điền vào đó sẽ giúp công cụ tự sinh mã 6 số cho bạn. Cách lấy giá trị: trong phần cài đặt bảo mật của Microsoft, mở "Manage how you sign in", thêm một ứng dụng authenticator, và khi mã QR hiện ra hãy chọn **"enter code manually"**. Dán đoạn mã đó làm giá trị.
+
+**Cài đặt đã xong.** Bạn không bao giờ phải lặp lại các bước từ 3.1 đến 3.5.
+
+---
+
+## 4. Khởi động Web UI
+
+Hai bước: đánh thức server, rồi mở trang web.
+
+### Bước 4.1 - Khởi động server
+
+Trong terminal của bạn (vẫn đang ở thư mục dự án), chạy:
+
+```bash
+npm run api
+```
+
+Bạn sẽ thấy vài dòng chữ khởi động, sau đó terminal có vẻ như **đứng yên**, không in ra gì thêm và không hiện dấu nhắc lệnh.
+
+**Điều đó là đúng.** Server giờ đang chạy và đang lắng nghe. Nó được thiết kế để nằm yên như vậy. Terminal không hề bị treo.
+
+> **Hãy để cửa sổ terminal này mở, đừng đóng nó.** Đóng lại là tắt server, và Web UI sẽ ngừng hoạt động. Thay vào đó hãy thu nhỏ cửa sổ.
+
+### Bước 4.2 - Mở trang web
+
+Mở trình duyệt bạn vẫn dùng hằng ngày (Chrome, Edge, Firefox, gì cũng được) và vào địa chỉ:
+
+```
+http://127.0.0.1:3010
+```
+
+`127.0.0.1` luôn có nghĩa là "chính máy tính này". Bạn không truy cập internet, chỉ là đang nối vào máy của mình.
+
+Bạn sẽ thấy bảng điều khiển **Microsoft Rewards Control**.
+
+Nhìn lên góc trên bên phải. Ở đó có nhãn **Server**:
+
+| Nhãn        | Ý nghĩa                                                                    |
+| ----------- | -------------------------------------------------------------------------- |
+| **Online**  | Server đang chạy, chưa có phiên nào đang chạy. Đây là trạng thái bạn muốn. |
+| **Running** | Đang có một phiên chạy ngay lúc này.                                       |
+| **Offline** | Trang web không kết nối được với server. Xem lại terminal ở bước 4.1.      |
+
+Nếu hiện Offline, nhiều khả năng terminal của server đã bị đóng hoặc đã báo lỗi.
+
+### Mỗi lần dùng sau này
+
+Khởi động công cụ chỉ gồm đúng hai bước đó:
+
+1. Mở terminal trong thư mục dự án, chạy `npm run api`
+2. Mở `http://127.0.0.1:3010`
+
+---
+
+## 5. Cách sử dụng Web UI
+
+Trang web là một cột duy nhất gồm các mục, từ trên xuống dưới. Dưới đây là từng mục.
+
+### 5.1 - Add Account (Thêm tài khoản)
+
+Ô ở trên cùng. Gõ địa chỉ email rồi bấm **Add Account**.
+
+Việc này sẽ tự ghi email vào file `.env` cho bạn, nên bạn không phải sửa tay file đó nữa. Tài khoản xuất hiện trong danh sách ngay lập tức.
+
+> **Quan trọng: giao diện cố ý không bao giờ hỏi mật khẩu của bạn.** Mật khẩu chỉ tồn tại trong file `.env` trên chính ổ đĩa của bạn. Nếu tài khoản vừa thêm cần mật khẩu, hãy mở `.env` bằng Notepad và thêm dòng tương ứng. Với tài khoản được thêm ở vị trí `ACCOUNT_2`, dòng cần thêm là `ACCOUNT_2_PASSWORD=yourpassword`.
+
+### 5.2 - Account Overview (Tổng quan tài khoản)
+
+Bốn ô đếm cho thấy tình trạng các tài khoản của bạn.
+
+| Ô đếm              | Ý nghĩa                                                   |
+| ------------------ | --------------------------------------------------------- |
+| **Total Accounts** | Công cụ biết bao nhiêu tài khoản                          |
+| **Logged In**      | Đã có phiên đăng nhập hợp lệ. Sẵn sàng chạy.              |
+| **Not Logged In**  | Chưa từng đăng nhập. Cần làm bước bên dưới.               |
+| **Login Expired**  | Từng đăng nhập nhưng phiên đã hết hạn. Cần đăng nhập lại. |
+
+**Một tài khoản mới tinh sẽ bắt đầu ở trạng thái "Not Logged In". Đó là chuyện bình thường.**
+
+### 5.3 - Đăng nhập lần đầu cho tài khoản mới
+
+Microsoft sẽ không để một con robot vượt qua bước đăng nhập mới một cách trơn tru, nên lần đầu tiên bạn phải tự đăng nhập. Chỉ một lần. Sau đó phiên đăng nhập sẽ được lưu lại.
+
+Mở một terminal **thứ hai** trong thư mục dự án (để yên terminal của server) và chạy lệnh này, thay bằng email của bạn:
+
+```bash
+npm run manual-login -- --email your.real.email@outlook.com
+```
+
+Một cửa sổ trình duyệt sẽ mở ra. Đăng nhập bình thường, y như mọi ngày, kể cả khi được hỏi mã 2FA. Khi bạn vào tới trang Rewards, **hãy đợi khoảng năm giây**. Cửa sổ sẽ tự đóng và phiên đăng nhập của bạn được lưu.
+
+Quay lại bảng điều khiển, tài khoản đó sẽ chuyển sang **Logged In** trong vòng vài giây.
+
+> Hãy làm lại bước này mỗi khi tài khoản hiện **Login Expired**. Đây là cách sửa chuẩn cho gần như mọi vấn đề đăng nhập.
+
+### 5.4 - Execution Settings (Cài đặt thực thi)
+
+Bốn nút điều khiển quyết định phiên chạy tiếp theo sẽ hoạt động _như thế nào_. **Hãy chỉnh chúng trước khi bấm Run.** Lựa chọn của bạn được trình duyệt ghi nhớ cho lần sau.
+
+**Run in Headless Mode (Chạy ở chế độ ẩn)**
+
+- **Tắt** (mặc định): bạn nhìn thấy các cửa sổ trình duyệt mở ra và tự bấm.
+- **Bật**: mọi thứ diễn ra vô hình ở nền.
+
+Để tắt thì tốt hơn khi bạn mới làm quen, vì bạn nhìn thấy chuyện gì đang xảy ra. Bật lên thì tiện hơn khi bạn đã tin tưởng nó, để các cửa sổ không giật mất màn hình lúc bạn đang làm việc khác.
+
+> Đừng dùng chế độ ẩn cho lần đăng nhập đầu tiên. Hãy dùng `manual-login` ở mục 5.3.
+
+**Run Visual Search (Chạy tìm kiếm bằng hình ảnh)**
+
+Mặc định là tắt. Bật lên để làm thêm các nhiệm vụ Bing Visual Search (loại nhiệm vụ tìm kiếm bằng hình ảnh thay vì bằng chữ) nhằm kiếm thêm điểm hằng ngày.
+
+**Run 30-Minute Edge Browsing (Chạy phiên duyệt Edge 30 phút)**
+
+Mặc định là tắt. Bật lên để hoàn thành phần thưởng duyệt Edge, khi đó công cụ sẽ duyệt web ở nền trong nửa giờ.
+
+> **Tính năng này làm phiên chạy kéo dài thêm ít nhất 30 phút.** Đó là yêu cầu của chính phần thưởng, không phải công cụ chạy chậm. Nó được đánh dấu là thử nghiệm vì Microsoft thỉnh thoảng thay đổi cách hoạt động.
+
+**Schedule for Later (Lên lịch để chạy sau)**
+
+Một ô chọn ngày và giờ. Hãy để **trống** nếu muốn chạy ngay. Chỉ điền vào khi bạn định dùng nút Schedule Run (xem mục 5.7).
+
+### 5.5 - Ready to Execute (Sẵn sàng thực thi)
+
+Danh sách tài khoản của bạn, cùng các nút hành động.
+
+Mỗi dòng tài khoản hiển thị một **ô checkbox**, **email**, số lần đã **chạy**, thời điểm chạy **gần nhất**, số **điểm**, và một **nhãn trạng thái**.
+
+**Cách chạy:**
+
+1. **Tích vào ô checkbox** của từng tài khoản bạn muốn chạy. Hoặc bấm **Select All** để tích hết (nút này sẽ đổi thành **Deselect All**).
+2. Kiểm tra lại các công tắc trong Execution Settings.
+3. Bấm **Run Selected**.
+
+Một thông báo nhỏ sẽ trượt ra xác nhận đã bắt đầu, nhãn Server chuyển sang **Running**, và các dòng log bắt đầu hiện ở cuối trang.
+
+**Điều nên biết:** một phiên chạy đầy đủ mất khá lâu, thường từ 20 đến 60 phút cho mỗi tài khoản, lâu hơn nếu bật Edge Browsing. Công cụ cố tình tạm nghỉ giữa các thao tác để hành xử giống người thật hơn là giống máy móc. Chậm là có chủ đích.
+
+**Nút Stop** bị mờ đi trừ khi thực sự có gì đó đang chạy. Bấm vào đó để kết thúc phiên chạy: nó yêu cầu bot tự đóng trình duyệt một cách gọn gàng, và nếu bot không phản hồi kịp thời thì server sẽ buộc đóng. Dù theo cách nào cũng không để sót cửa sổ trình duyệt mồ côi.
+
+**Nút Remove** chỉ gỡ tài khoản khỏi danh sách này, nhưng **không xóa nó khỏi file `.env`**, nên tài khoản sẽ xuất hiện lại ở lần làm mới trang kế tiếp. Muốn xóa hẳn một tài khoản, hãy mở `.env` bằng Notepad và xóa dòng `ACCOUNT_N_EMAIL` của nó.
+
+### 5.6 - Proxy cho từng tài khoản
+
+Mỗi dòng tài khoản có một nút **Proxy**. Bấm vào đó để mở khung sửa proxy ngay bên dưới danh sách.
+
+Khung này cho bạn nhập **Proxy address**, **Port**, **Username**, **Password**, và một công tắc **Use for API requests too**. Sau khi lưu, dòng tài khoản sẽ hiện một **huy hiệu xanh** `host:port` để bạn biết tài khoản đó đã có proxy.
+
+**Bạn chỉ cần quan tâm mục này nếu chạy nhiều tài khoản.** Nếu chỉ có 1 tài khoản thì bỏ qua.
+
+> 📖 **Proxy là gì, chọn loại nào, mua ở đâu, sửa lỗi ra sao** — xem tài liệu riêng: **`PROXY_GUIDE.vi.md`**. Tài liệu đó viết riêng cho người chưa từng dùng proxy bao giờ.
+
+**Bốn điều cần nhớ ngay:**
+
+- **Một tài khoản phải dùng một proxy riêng.** Nhiều tài khoản dùng chung một proxy thì proxy mất hết tác dụng.
+- **Tài khoản/mật khẩu proxy để ở ô riêng**, không nhập vào ô Proxy address.
+- **SOCKS proxy không dùng được mật khẩu** — chỉ dùng HTTP hoặc HTTPS nếu proxy có đăng nhập.
+- **Thay đổi chỉ áp dụng cho lần chạy tới.** Tool đang chạy thì không sửa được, phải bấm **Stop** trước.
+
+### 5.7 - Scheduled Tasks (Các tác vụ đã lên lịch)
+
+Liệt kê các phiên chạy bạn đã xếp hàng cho một thời điểm trong tương lai. Mỗi mục hiển thị giờ chạy, những tài khoản nào, và một nút **Cancel**.
+
+### 5.8 - Cách lên lịch một phiên chạy
+
+1. Tích chọn các tài khoản bạn muốn.
+2. Đặt ngày và giờ trong **Schedule for Later**. Thời điểm đó phải ở tương lai, và tính theo đồng hồ của chính máy bạn.
+3. Bấm **Schedule Run**.
+
+**Có hai điều kiện phải đúng thì phiên chạy đã lên lịch mới thực sự khởi động:**
+
+- Tính năng lên lịch phải được bật. Nó **mặc định là tắt** như một biện pháp an toàn. Xem [mục 6](#6-tùy-chọn-bật-tính-năng-lên-lịch). Nếu đang tắt, bạn sẽ nhận thông báo lỗi có nhắc tới `API_ALLOW_SCHEDULE_WRITE`.
+- **Terminal của server vẫn phải đang chạy khi đến giờ**, và máy tính phải đang ở trạng thái thức. Người phục vụ đã về nhà thì không ai bắt đầu phiên chạy được.
+
+### 5.9 - Live Logs (Log trực tiếp)
+
+Bảng console màu đen ở cuối trang. Đây là nơi bot tường thuật những gì nó đang làm, theo thời gian thực.
+
+Mỗi dòng có thời điểm, mức độ và nội dung thông báo. Phần mức độ là phần hữu ích nhất:
+
+| Mức độ    | Màu sắc     | Ý nghĩa                                              |
+| --------- | ----------- | ---------------------------------------------------- |
+| **INFO**  | Bình thường | Tiến trình thông thường. Có thể bỏ qua.              |
+| **WARN**  | Vàng        | Có gì đó bị bỏ qua hoặc được thử lại. Thường vô hại. |
+| **ERROR** | Đỏ          | Thực sự có lỗi. Đáng để đọc.                         |
+
+**Auto-scroll** (mặc định bật) giữ dòng mới nhất luôn nằm trong tầm nhìn. Hãy tắt nó khi bạn muốn cuộn lên đọc lại thứ gì đó mà không bị kéo tuột xuống dưới.
+
+**Clear** xóa trắng phần hiển thị. Nó chỉ xóa những gì bạn đang thấy, không xóa dữ liệu trên server, nên tải lại trang sẽ mang phần lịch sử gần đây trở lại.
+
+Console giữ tối đa 500 dòng gần nhất và phát lại 100 dòng cuối khi bạn mở trang, để bạn không quay lại một màn hình trống trơn.
+
+**Khi có chuyện trục trặc, đây là nơi đầu tiên cần xem.** Cuộn tới các dòng màu đỏ và đọc nội dung.
+
+---
+
+## 6. Tùy chọn: bật tính năng lên lịch
+
+Tính năng lên lịch mặc định bị tắt, để không gì có thể tự xếp hàng phiên chạy trên máy của bạn nếu bạn không chủ động cho phép. Bật nó lên chỉ cần thêm một dòng.
+
+1. Dừng server: bấm vào cửa sổ terminal của nó và nhấn **Ctrl+C**.
+2. Mở file `.env` bằng Notepad.
+3. Thêm dòng này vào cuối file:
+
+```env
+API_ALLOW_SCHEDULE_WRITE=true
+```
+
+4. Lưu và đóng lại.
+5. Khởi động server lần nữa bằng `npm run api`.
+
+Giờ **Schedule Run** đã hoạt động.
+
+---
+
+## 7. Xử lý sự cố
+
+### Trang web báo "Offline"
+
+Server không chạy hoặc không kết nối được.
+
+- Kiểm tra terminal nơi bạn chạy `npm run api`. Còn mở không? Có chữ màu đỏ nào không?
+- Nếu nó đã bị đóng, chạy lại `npm run api`.
+- Xác nhận địa chỉ đúng là `http://127.0.0.1:3010`.
+
+### "Port 3010 is already in use"
+
+Đã có một server đang chạy, nhiều khả năng là từ trước đó. Hoặc dùng luôn cái đang chạy (chỉ cần mở trang web), hoặc đóng cửa sổ terminal kia rồi thử lại.
+
+### Một tài khoản cứ kẹt ở "Not Logged In" hoặc "Login Expired"
+
+Hãy chạy bước đăng nhập thủ công ở mục 5.3. Cách này sửa được phần lớn các vấn đề đăng nhập.
+
+```bash
+npm run manual-login -- --email your.real.email@outlook.com
+```
+
+Nếu nó cứ hết hạn mãi, hãy xóa các phiên đã lưu và bắt đầu sạch sẽ:
+
+```bash
+npm run clear-sessions -- email your.real.email@outlook.com
+```
+
+Rồi đăng nhập thủ công lại lần nữa.
+
+### "No accounts configured in .env yet"
+
+Email có trong danh sách trên trình duyệt của bạn nhưng chưa có trong file `.env`. Hãy thêm lại qua ô **Add Account**, ô đó sẽ ghi file giúp bạn.
+
+### Bấm Run Selected mà không thấy gì
+
+- Bạn đã tích ít nhất một ô checkbox chưa? Chọn tài khoản là việc riêng với chạy chúng.
+- Nhãn trạng thái có đang hiện **Running** không? Mỗi lần chỉ có một phiên chạy, nên nút này bị vô hiệu hóa khi đang có phiên chạy.
+
+### Visual Search hoặc Edge Browsing không diễn ra
+
+Hãy xác nhận công tắc đã **bật trước khi** bạn bấm Run Selected, chứ không phải sau đó. Rồi kiểm tra trong Live Logs xem có dòng như thế này không:
+
+```
+[Config] override: CONFIG_WORKER_VISUAL_SEARCH -> .workers.doVisualSearch = true
+```
+
+Dòng đó là công cụ xác nhận đã nhận được lựa chọn của bạn. Nếu nó có mặt, tính năng đã được bật cho phiên chạy đó. Nếu sau đó tính năng vẫn bị bỏ qua, phần log ngay bên dưới sẽ nói rõ lý do, thường là tài khoản không có nhiệm vụ đó trong ngày hôm ấy.
+
+### Một lệnh báo lỗi với rất nhiều chữ đỏ
+
+Hãy thử lần lượt:
+
+1. `npm run build` rồi thử lại.
+2. Nếu vẫn lỗi, chạy `npm run pre-build` rồi tới `npm run build`.
+3. Kiểm tra cả `config.json` và `.env` đều tồn tại và được đặt tên chính xác. Thiếu `config.json` là một trong những nguyên nhân phổ biến nhất.
+
+### Cửa sổ trình duyệt còn mở sau khi bị lỗi
+
+Trên Windows:
+
+```bash
+npm run kill-chrome-win
+```
+
+---
+
+## 8. Lưu ý về an toàn và bảo mật
+
+**Thông tin đăng nhập của bạn nằm lại trên máy bạn.** Mật khẩu chỉ tồn tại trong file `.env` trên chính ổ đĩa của bạn. Web UI không bao giờ hỏi, không bao giờ hiển thị và không bao giờ gửi chúng đi đâu cả. Đừng bao giờ chia sẻ file `.env`, và đừng đăng nó lên ảnh chụp màn hình hay một chủ đề hỗ trợ kỹ thuật.
+
+**Bảng điều khiển mặc định không có mật khẩu bảo vệ.** Nó được gắn vào `127.0.0.1`, nghĩa là chỉ các chương trình trên chính máy bạn mới truy cập được. Người khác trong cùng mạng Wi-Fi thì không. Đó là một thiết lập mặc định có chủ ý.
+
+Nếu bạn thay đổi để server lắng nghe trên cả mạng (bằng thứ gì đó như `--host 0.0.0.0`), **hãy đặt token trước**, nếu không bất kỳ ai trong mạng đó cũng có thể khởi động phiên chạy trên tài khoản của bạn. Thêm một dòng như `API_TOKEN=some-long-random-string` vào `.env` trước khi làm việc đó.
+
+**Đừng đưa `.env` hoặc `config.json` lên một kho GitHub công khai.** Dự án đã cấu hình để Git bỏ qua cả hai file này, nên chuyện đó chỉ xảy ra nếu bạn cố tình làm. Đừng làm.
+
+**Mật khẩu proxy cũng nằm trong `.env`.** Khi bạn lưu proxy qua Web UI, thông tin proxy được ghi vào `.env` dưới dạng các dòng `ACCOUNT_N_PROXY_*`. Web UI **không bao giờ hiển thị lại** mật khẩu proxy đã lưu — đó là lý do ô Password luôn trống mỗi khi bạn mở lại khung sửa. Cùng quy tắc như trên: đừng chia sẻ file này.
+
+**Về rủi ro với tài khoản của bạn.** Tự động hóa Microsoft Rewards là trái với điều khoản dịch vụ của Microsoft. Tài khoản thực sự có thể bị tạm khóa hoặc bị cấm vì việc này. Công cụ cố gắng hành xử giống người thật, với các khoảng nghỉ hợp lý, nhưng không có gì bảo đảm. Hãy dùng nó với một tài khoản mà bạn chấp nhận được nếu mất, và hiểu rằng bạn đang tự nhận lấy rủi ro đó.
+
+---
+
+## Tra cứu nhanh
+
+**Khởi động hằng ngày:**
+
+```bash
+npm run api
+```
+
+Rồi mở `http://127.0.0.1:3010`.
+
+**Các lệnh thường dùng:**
+
+| Lệnh                                              | Tác dụng                                     |
+| ------------------------------------------------- | -------------------------------------------- |
+| `npm run api`                                     | Khởi động server cho Web UI                  |
+| `npm run build`                                   | Áp dụng các thay đổi bạn đã làm vào file     |
+| `npm run manual-login -- --email you@example.com` | Đăng nhập tài khoản bằng tay                 |
+| `npm run clear-sessions -- list`                  | Xem các phiên đăng nhập đã lưu               |
+| `npm run clear-sessions -- email you@example.com` | Xóa phiên đăng nhập đã lưu của một tài khoản |
+| `npm run kill-chrome-win`                         | Đóng các cửa sổ trình duyệt bị kẹt (Windows) |
+
+**Các file quan trọng:**
+
+| File          | Chứa gì                                        |
+| ------------- | ---------------------------------------------- |
+| `.env`        | Email, mật khẩu của bạn và các tùy chọn server |
+| `config.json` | Cách bot hoạt động                             |
+
+**Phím tắt:** nhấn **Ctrl+C** trong terminal của server để dừng server.
+
+**Tài liệu khác:**
+
+| File                 | Nội dung                                                                 |
+| -------------------- | ------------------------------------------------------------------------ |
+| `WEB_UI_GUIDE.vi.md` | Hướng dẫn Web UI dành cho người mới (file này)                           |
+| `PROXY_GUIDE.vi.md`  | Hướng dẫn cài đặt proxy từ A đến Z — loại nào, mua ở đâu, sửa lỗi ra sao |
diff --git a/eslint.config.mjs b/eslint.config.mjs
index c1e6c787..ea438f1a 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -25,6 +25,15 @@ export default tseslint.config(
             'preserve-caught-error': 'off'
         }
     },
+    // Browser-side dashboard code
+    {
+        files: ['public/**/*.js'],
+        languageOptions: {
+            globals: {
+                ...globals.browser
+            }
+        }
+    },
     // Must come last: disables ESLint rules that conflict with Prettier formatting
     prettier
 )
diff --git a/package.json b/package.json
index 9e736bc9..43f721cd 100644
--- a/package.json
+++ b/package.json
@@ -19,7 +19,9 @@
         "create-docker": "docker build -t microsoft-rewards-script-docker .",
         "lint": "eslint .",
         "lint:fix": "eslint . --fix",
+        "test": "node --test scripts/api/logParser.test.js tests/*.test.mjs",
         "test:log-parser": "node --test scripts/api/logParser.test.js",
+        "test:abort": "node --test tests/abort.test.mjs",
         "format": "prettier --write .",
         "format:check": "prettier --check .",
         "clear-diagnostics": "rimraf diagnostics",
diff --git a/public/README.md b/public/README.md
new file mode 100644
index 00000000..78d62f72
--- /dev/null
+++ b/public/README.md
@@ -0,0 +1,66 @@
+# Web UI for Microsoft Rewards Script
+
+A simplified, accessible web interface for managing Microsoft Rewards accounts.
+
+## Features
+
+- **Add accounts with email only** - no coding knowledge required
+- **Real-time dashboard** - view server status and account statistics
+- **Account queue** - see all accounts ready to execute
+- **Live point balance** - track points for each account
+- **Status tracking** - see which accounts are logged in, expired, or not logged in
+- **Selective execution** - choose which accounts to run with checkboxes
+- **Responsive design** - works on desktop, tablet, and mobile
+
+## Setup
+
+1. Start the API server:
+
+```bash
+npm run api
+```
+
+2. Open your browser to:
+
+```
+http://127.0.0.1:3010
+```
+
+3. Add accounts using the email form
+4. Select accounts and click "Run Selected"
+
+## Configuration
+
+The Web UI connects to the Control API at `http://127.0.0.1:3010` by default.
+
+To change the API URL, edit `public/app.js`:
+
+```javascript
+const API_BASE_URL = 'http://your-server:3010'
+```
+
+## How It Works
+
+- Accounts are stored in browser localStorage for persistence
+- The UI polls the API every 5 seconds for status updates
+- Point balances and run history come from the Control API
+- Account credentials remain in your `.env` file (not exposed to the UI)
+
+## Adding Accounts to .env
+
+After adding an account via the UI, you still need to add credentials to `.env`:
+
+```env
+ACCOUNT_1_EMAIL=email@example.com
+ACCOUNT_1_PASSWORD=your_password
+```
+
+Then rebuild: `npm run build`
+
+## Accessibility
+
+- Keyboard navigable
+- Screen reader compatible
+- ARIA labels on interactive elements
+- High contrast color scheme
+- Focus indicators on all controls
diff --git a/public/app.js b/public/app.js
new file mode 100644
index 00000000..8f1eeddc
--- /dev/null
+++ b/public/app.js
@@ -0,0 +1,891 @@
+// Configuration
+const API_BASE_URL = 'http://127.0.0.1:3010'
+const POLL_INTERVAL = 5000 // 5 seconds
+const MAX_LOG_LINES = 500
+
+// State
+let accounts = []
+let selectedAccountIndexes = new Set()
+let scheduledTasks = []
+let logSource = null
+let proxyAccountIndex = null
+
+// DOM Elements
+const emailInput = document.getElementById('emailInput')
+const addAccountForm = document.getElementById('addAccountForm')
+const accountsList = document.getElementById('accountsList')
+const serverStatusEl = document.getElementById('serverStatus')
+const totalAccountsEl = document.getElementById('totalAccounts')
+const loggedInCountEl = document.getElementById('loggedInCount')
+const notLoggedInCountEl = document.getElementById('notLoggedInCount')
+const expiredCountEl = document.getElementById('expiredCount')
+const selectAllBtn = document.getElementById('selectAllBtn')
+const runSelectedBtn = document.getElementById('runSelectedBtn')
+const scheduleSelectedBtn = document.getElementById('scheduleSelectedBtn')
+const headlessToggle = document.getElementById('headlessToggle')
+const visualSearchToggle = document.getElementById('visualSearchToggle')
+const edgeBrowsingToggle = document.getElementById('edgeBrowsingToggle')
+const stopBtn = document.getElementById('stopBtn')
+const scheduleTimeInput = document.getElementById('scheduleTime')
+const scheduledList = document.getElementById('scheduledList')
+const logsConsole = document.getElementById('logsConsole')
+const autoScrollToggle = document.getElementById('autoScrollToggle')
+const clearLogsBtn = document.getElementById('clearLogsBtn')
+const toast = document.getElementById('toast')
+const proxyForm = document.getElementById('proxyForm')
+const proxyEmpty = document.getElementById('proxyEmpty')
+const proxyAccountEmail = document.getElementById('proxyAccountEmail')
+const proxyUrlInput = document.getElementById('proxyUrlInput')
+const proxyPortInput = document.getElementById('proxyPortInput')
+const proxyUsernameInput = document.getElementById('proxyUsernameInput')
+const proxyPasswordInput = document.getElementById('proxyPasswordInput')
+const proxyPasswordHint = document.getElementById('proxyPasswordHint')
+const proxyHttpToggle = document.getElementById('proxyHttpToggle')
+const proxyCancelBtn = document.getElementById('proxyCancelBtn')
+const proxyClearBtn = document.getElementById('proxyClearBtn')
+
+// Initialize
+document.addEventListener('DOMContentLoaded', () => {
+    loadFromLocalStorage()
+    loadScheduledTasks()
+    setupEventListeners()
+    checkServerHealth()
+    startPolling()
+    connectLogStream()
+
+    // Load saved run preferences
+    restoreToggle('headless_mode', headlessToggle)
+    restoreToggle('visual_search', visualSearchToggle)
+    restoreToggle('edge_browsing', edgeBrowsingToggle)
+})
+
+function restoreToggle(key, element) {
+    const saved = localStorage.getItem(key)
+    if (saved !== null) element.checked = saved === 'true'
+}
+
+function setupEventListeners() {
+    addAccountForm.addEventListener('submit', handleAddAccount)
+    selectAllBtn.addEventListener('click', handleSelectAll)
+    runSelectedBtn.addEventListener('click', handleRunSelected)
+    scheduleSelectedBtn.addEventListener('click', handleScheduleSelected)
+    headlessToggle.addEventListener('change', handleHeadlessToggle)
+    visualSearchToggle.addEventListener('change', () =>
+        localStorage.setItem('visual_search', visualSearchToggle.checked)
+    )
+    edgeBrowsingToggle.addEventListener('change', () =>
+        localStorage.setItem('edge_browsing', edgeBrowsingToggle.checked)
+    )
+    stopBtn.addEventListener('click', handleStop)
+    clearLogsBtn.addEventListener('click', handleClearLogs)
+    proxyForm.addEventListener('submit', handleSaveProxy)
+    proxyCancelBtn.addEventListener('click', closeProxyEditor)
+    proxyClearBtn.addEventListener('click', handleClearProxy)
+}
+
+// Proxy editor — edits ACCOUNT_N_PROXY_* in .env through the control API.
+function openProxyEditor(index) {
+    const account = accounts.find(acc => acc.index === index)
+    if (!account) return
+
+    proxyAccountIndex = index
+    proxyAccountEmail.textContent = account.email
+    proxyEmpty.hidden = true
+    proxyForm.hidden = false
+
+    // Reset first so a failed load cannot leave the previous account's values on screen.
+    proxyUrlInput.value = ''
+    proxyPortInput.value = ''
+    proxyUsernameInput.value = ''
+    proxyPasswordInput.value = ''
+    proxyHttpToggle.checked = false
+
+    fetch(`${API_BASE_URL}/accounts/${index}/proxy`)
+        .then(response => (response.ok ? response.json() : Promise.reject(new Error('load failed'))))
+        .then(data => {
+            // Ignore a response that arrived after the user switched accounts.
+            if (proxyAccountIndex !== index) return
+            const proxy = data.proxy || {}
+            proxyUrlInput.value = proxy.url || ''
+            proxyPortInput.value = proxy.port ? String(proxy.port) : ''
+            proxyUsernameInput.value = proxy.username || ''
+            proxyHttpToggle.checked = Boolean(proxy.proxyHttp)
+            proxyPasswordHint.textContent = proxy.hasPassword
+                ? 'A password is saved. Leave blank to keep it.'
+                : 'No password saved yet.'
+        })
+        .catch(() => showToast('Could not load the saved proxy', 'error'))
+
+    proxyForm.scrollIntoView({ behavior: 'smooth', block: 'center' })
+}
+
+function closeProxyEditor() {
+    proxyAccountIndex = null
+    proxyForm.hidden = true
+    proxyEmpty.hidden = false
+    proxyAccountEmail.textContent = 'an account'
+}
+
+function proxyPayloadFromForm() {
+    const body = {
+        url: proxyUrlInput.value.trim(),
+        username: proxyUsernameInput.value.trim(),
+        proxyHttp: proxyHttpToggle.checked
+    }
+    // Omit blanks: the port field is only meaningful with a URL, and an empty
+    // password means "keep the stored one".
+    const port = proxyPortInput.value.trim()
+    if (port) body.port = Number(port)
+    if (proxyPasswordInput.value) body.password = proxyPasswordInput.value
+    return body
+}
+
+async function saveProxy(body, successMessage) {
+    const index = proxyAccountIndex
+    if (index == null) return false
+
+    try {
+        const response = await fetch(`${API_BASE_URL}/accounts/${index}/proxy`, {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body)
+        })
+        const data = await response.json().catch(() => ({}))
+
+        if (!response.ok) {
+            showToast(data.error || 'Failed to save the proxy', 'error')
+            return false
+        }
+
+        showToast(successMessage, 'success')
+        closeProxyEditor()
+        await checkServerHealth()
+        return true
+    } catch {
+        showToast('Failed to connect to server', 'error')
+        return false
+    }
+}
+
+async function handleSaveProxy(e) {
+    e.preventDefault()
+    await saveProxy(proxyPayloadFromForm(), 'Proxy saved - it applies to the next run')
+}
+
+async function handleClearProxy() {
+    if (!confirm('Remove the proxy for this account?')) return
+    await saveProxy({ url: '', proxyHttp: false }, 'Proxy removed')
+}
+
+// Live log stream (Server-Sent Events)
+function connectLogStream() {
+    if (logSource) logSource.close()
+
+    logsConsole.innerHTML = '<div class="log-empty">Connecting to log stream...</div>'
+
+    const source = new EventSource(`${API_BASE_URL}/events?replay=100`)
+    logSource = source
+
+    source.addEventListener('hello', event => {
+        const status = JSON.parse(event.data)
+        updateServerStatus(status.state === 'running' ? 'running' : 'online')
+        logsConsole.innerHTML = ''
+    })
+
+    source.addEventListener('log', event => {
+        appendLogLine(JSON.parse(event.data))
+    })
+
+    source.addEventListener('status', event => {
+        const status = JSON.parse(event.data)
+        updateServerStatus(status.state === 'running' ? 'running' : 'online')
+    })
+
+    source.onerror = () => {
+        updateServerStatus('offline')
+        // EventSource reconnects on its own; surface the gap without spamming.
+        if (!logsConsole.querySelector('.log-empty')) {
+            appendLogLine({ level: 'warn', message: 'Log stream disconnected - reconnecting...' })
+        }
+    }
+
+    window.addEventListener('beforeunload', () => source.close())
+}
+
+function appendLogLine(entry) {
+    const empty = logsConsole.querySelector('.log-empty')
+    if (empty) empty.remove()
+
+    const line = document.createElement('div')
+    line.className = 'log-line'
+    line.dataset.level = entry.level || 'info'
+
+    const time = document.createElement('span')
+    time.className = 'log-time'
+    time.textContent = formatLogTime(entry)
+
+    const level = document.createElement('span')
+    level.className = 'log-level'
+    level.textContent = (entry.level || 'info').toUpperCase()
+
+    const message = document.createElement('span')
+    message.className = 'log-message'
+    message.textContent = entry.title ? `[${entry.title}] ${entry.message ?? ''}` : (entry.message ?? '')
+
+    line.append(time, level, message)
+    logsConsole.append(line)
+
+    while (logsConsole.childElementCount > MAX_LOG_LINES) {
+        logsConsole.firstElementChild.remove()
+    }
+
+    const shouldScroll = autoScrollToggle.checked
+    const nearBottom = logsConsole.scrollHeight - logsConsole.scrollTop - logsConsole.clientHeight < 80
+    if (shouldScroll && nearBottom) {
+        logsConsole.scrollTop = logsConsole.scrollHeight
+    }
+}
+
+function formatLogTime(entry) {
+    const raw = entry.ts || entry.receivedAt
+    if (!raw) return '--:--:--'
+    const date = new Date(raw)
+    if (Number.isNaN(date.getTime())) return '--:--:--'
+    return date.toLocaleTimeString(undefined, { hour12: false })
+}
+
+function handleClearLogs() {
+    logsConsole.innerHTML = ''
+}
+
+// API Functions
+async function checkServerHealth() {
+    try {
+        const response = await fetch(`${API_BASE_URL}/health`)
+        const data = await response.json()
+
+        if (data.ok) {
+            updateServerStatus(data.state === 'running' ? 'running' : 'online')
+            await fetchAccounts()
+        }
+    } catch {
+        updateServerStatus('offline')
+    }
+}
+
+async function fetchAccounts() {
+    try {
+        const response = await fetch(`${API_BASE_URL}/accounts`)
+        const data = await response.json()
+
+        if (data.accounts) {
+            const apiAccounts = new Map()
+            const apiAccountEmails = new Set()
+
+            // Map API accounts by email - session-derived status wins so the
+            // badge reflects live cookies, not empty post-restart run history.
+            for (const acc of data.accounts) {
+                apiAccountEmails.add(acc.email)
+                apiAccounts.set(acc.email, {
+                    index: acc.index,
+                    email: acc.email,
+                    points: acc.lastCollected || 0,
+                    status: acc.sessionStatus ? acc.sessionStatus : determineAccountStatus(acc),
+                    sessionStatus: acc.sessionStatus ?? null,
+                    sessionUpdatedAt: acc.sessionUpdatedAt ?? null,
+                    runs: acc.runs || 0,
+                    lastRunAt: acc.lastRunAt,
+                    lastSuccess: acc.lastSuccess,
+                    isConfigured: true // Mark as configured in API
+                })
+            }
+
+            // Merge: update existing localStorage accounts with API data
+            accounts = accounts.map(localAcc => {
+                const apiData = apiAccounts.get(localAcc.email)
+                if (apiData) {
+                    // Account exists in API, merge live data
+                    return { ...localAcc, ...apiData }
+                }
+                // Account only in localStorage (not yet in .env)
+                return { ...localAcc, isConfigured: false }
+            })
+
+            // Adopt accounts that exist in .env but were never seen by this browser
+            const knownEmails = new Set(accounts.map(acc => acc.email))
+            for (const [email, apiData] of apiAccounts) {
+                if (!knownEmails.has(email)) accounts.push(apiData)
+            }
+
+            saveToLocalStorage()
+            renderAccounts()
+            updateStats()
+        }
+    } catch (error) {
+        console.error('Failed to fetch accounts:', error)
+    }
+}
+
+function determineAccountStatus(account) {
+    if (!account.lastRunAt) return 'not-logged-in'
+    if (account.lastSuccess === true) return 'logged-in'
+    if (account.lastSuccess === false) return 'expired'
+    return 'not-logged-in'
+}
+
+async function startMultipleAccounts(accountIndexes, options = {}) {
+    try {
+        const { headless = false, visualSearch = false, edgeBrowsing = false } = options
+
+        // Only work with accounts that are configured in the API
+        const apiAccounts = accounts.filter(acc => acc.isConfigured)
+
+        if (apiAccounts.length === 0) {
+            showToast('No accounts configured in .env yet. Add credentials and rebuild.', 'warning')
+            return
+        }
+
+        // Filter selected indexes to only include API-backed accounts
+        const validIndexes = accountIndexes.filter(idx => apiAccounts.some(acc => acc.index === idx))
+
+        if (validIndexes.length === 0) {
+            showToast('Selected accounts are not configured in .env yet', 'warning')
+            return
+        }
+
+        const allApiIndexes = apiAccounts.map(acc => acc.index)
+        const excludedIndexes = allApiIndexes.filter(idx => !validIndexes.includes(idx))
+
+        // These map onto config.json paths; both features are off in config by
+        // default, so without the overrides they never run.
+        const body = {
+            env: {
+                CONFIG_HEADLESS: headless ? 'true' : 'false',
+                CONFIG_WORKER_VISUAL_SEARCH: visualSearch ? 'true' : 'false',
+                CONFIG_EXPERIMENTAL_EDGE_BROWSING: edgeBrowsing ? 'true' : 'false'
+            }
+        }
+
+        if (excludedIndexes.length > 0) {
+            body.excludedAccountIndexes = excludedIndexes
+        }
+
+        const response = await fetch(`${API_BASE_URL}/start`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body)
+        })
+
+        const data = await response.json()
+
+        if (response.ok) {
+            showToast(`Started ${validIndexes.length} account(s)${headless ? ' in headless mode' : ''}`, 'success')
+            await checkServerHealth()
+            return true
+        } else {
+            showToast(data.error || 'Failed to start accounts', 'error')
+            return false
+        }
+    } catch {
+        showToast('Failed to connect to server', 'error')
+        return false
+    }
+}
+
+// Event Handlers
+async function handleAddAccount(e) {
+    e.preventDefault()
+
+    const email = emailInput.value.trim()
+
+    if (!email) {
+        showToast('Please enter an email address', 'error')
+        return
+    }
+
+    if (accounts.some(acc => acc.email.toLowerCase() === email.toLowerCase())) {
+        showToast('Account already exists', 'warning')
+        return
+    }
+
+    const submitBtn = addAccountForm.querySelector('button[type="submit"]')
+    submitBtn.disabled = true
+    submitBtn.textContent = 'Adding...'
+
+    try {
+        const response = await fetch(`${API_BASE_URL}/accounts`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ email })
+        })
+        const data = await response.json()
+
+        if (response.ok) {
+            accounts.push({
+                index: data.index,
+                email: data.email,
+                points: 0,
+                status: 'not-logged-in',
+                runs: 0,
+                lastRunAt: null,
+                lastSuccess: null,
+                isConfigured: true
+            })
+            saveToLocalStorage()
+            renderAccounts()
+            updateStats()
+            emailInput.value = ''
+            showToast(`${data.email} added and ready to run`, 'success')
+        } else {
+            showToast(data.error || 'Failed to add account', 'error')
+        }
+    } catch {
+        showToast('Failed to connect to server', 'error')
+    }
+
+    submitBtn.disabled = false
+    submitBtn.textContent = 'Add Account'
+}
+
+function handleSelectAll() {
+    if (selectedAccountIndexes.size === accounts.length) {
+        selectedAccountIndexes.clear()
+        selectAllBtn.textContent = 'Select All'
+    } else {
+        accounts.forEach(acc => selectedAccountIndexes.add(acc.index))
+        selectAllBtn.textContent = 'Deselect All'
+    }
+    renderAccounts()
+}
+
+async function handleRunSelected() {
+    if (selectedAccountIndexes.size === 0) {
+        showToast('Please select at least one account', 'warning')
+        return
+    }
+
+    runSelectedBtn.disabled = true
+    runSelectedBtn.textContent = 'Starting...'
+
+    const indexArray = Array.from(selectedAccountIndexes)
+    const success = await startMultipleAccounts(indexArray, {
+        headless: headlessToggle.checked,
+        visualSearch: visualSearchToggle.checked,
+        edgeBrowsing: edgeBrowsingToggle.checked
+    })
+
+    runSelectedBtn.disabled = false
+    runSelectedBtn.textContent = 'Run Selected'
+
+    if (success) {
+        selectedAccountIndexes.clear()
+        selectAllBtn.textContent = 'Select All'
+        renderAccounts()
+    }
+}
+
+async function handleScheduleSelected() {
+    if (selectedAccountIndexes.size === 0) {
+        showToast('Please select at least one account', 'warning')
+        return
+    }
+
+    const scheduleTime = scheduleTimeInput.value
+    if (!scheduleTime) {
+        showToast('Please select a date and time', 'warning')
+        return
+    }
+
+    const scheduledDate = new Date(scheduleTime)
+    const now = new Date()
+
+    if (scheduledDate <= now) {
+        showToast('Schedule time must be in the future', 'warning')
+        return
+    }
+
+    scheduleSelectedBtn.disabled = true
+    scheduleSelectedBtn.textContent = 'Scheduling...'
+
+    const indexArray = Array.from(selectedAccountIndexes)
+    const headless = headlessToggle.checked
+    const visualSearch = visualSearchToggle.checked
+    const edgeBrowsing = edgeBrowsingToggle.checked
+    const accountEmails = accounts.filter(acc => indexArray.includes(acc.index)).map(acc => acc.email)
+
+    try {
+        const response = await fetch(`${API_BASE_URL}/schedule/tasks`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                accountIndexes: indexArray,
+                scheduledAt: scheduledDate.toISOString(),
+                headless,
+                visualSearch,
+                edgeBrowsing
+            })
+        })
+
+        const data = await response.json()
+
+        if (response.ok) {
+            const task = {
+                id: data.task.id,
+                accountIndexes: indexArray,
+                accountEmails,
+                scheduledAt: scheduledDate.toISOString(),
+                headless,
+                visualSearch,
+                edgeBrowsing,
+                createdAt: new Date().toISOString()
+            }
+
+            scheduledTasks.push(task)
+            saveScheduledTasks()
+            renderScheduledTasks()
+
+            const timeStr = scheduledDate.toLocaleString()
+            showToast(`Accounts scheduled to run at ${timeStr}`, 'success')
+
+            selectedAccountIndexes.clear()
+            selectAllBtn.textContent = 'Select All'
+            scheduleTimeInput.value = ''
+            renderAccounts()
+        } else {
+            showToast(data.error || 'Failed to schedule task', 'error')
+        }
+    } catch {
+        showToast('Failed to connect to server', 'error')
+    }
+
+    scheduleSelectedBtn.disabled = false
+    scheduleSelectedBtn.textContent = 'Schedule Run'
+}
+
+function handleHeadlessToggle() {
+    localStorage.setItem('headless_mode', headlessToggle.checked)
+}
+
+async function handleStop() {
+    stopBtn.disabled = true
+    stopBtn.textContent = 'Stopping...'
+
+    try {
+        const response = await fetch(`${API_BASE_URL}/stop`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ force: false })
+        })
+
+        if (response.ok) {
+            showToast('Stopping run - closing browsers...', 'warning')
+        } else {
+            const data = await response.json().catch(() => ({}))
+            showToast(data.error || 'Failed to stop the run', 'error')
+        }
+    } catch {
+        showToast('Failed to connect to server', 'error')
+    }
+
+    stopBtn.textContent = 'Stop'
+    // updateServerStatus re-enables it while a run is still active.
+    await checkServerHealth()
+}
+
+function handleAccountCheckbox(index, checked) {
+    if (checked) {
+        selectedAccountIndexes.add(index)
+    } else {
+        selectedAccountIndexes.delete(index)
+    }
+
+    selectAllBtn.textContent = selectedAccountIndexes.size === accounts.length ? 'Deselect All' : 'Select All'
+    renderAccounts()
+}
+
+async function handleDeleteAccount(index) {
+    const account = accounts.find(acc => acc.index === index)
+    if (!account) return
+
+    const label = account.email
+    if (!account.isConfigured) {
+        showToast(`${label} is not in .env yet, so there is nothing to remove.`, 'warning')
+        return
+    }
+    if (!confirm(`Remove ${label} from .env?\n\nThis also deletes its saved sign-in sessions.`)) return
+
+    try {
+        const response = await fetch(`${API_BASE_URL}/accounts/${index}`, { method: 'DELETE' })
+        const data = await response.json().catch(() => ({}))
+
+        if (!response.ok) {
+            showToast(data.error || 'Failed to remove the account', 'error')
+            return
+        }
+
+        // Drop it locally now so the row goes before the next poll lands.
+        accounts = accounts.filter(acc => acc.index !== index)
+        selectedAccountIndexes.delete(index)
+        saveToLocalStorage()
+        renderAccounts()
+        updateStats()
+        const sessions = data.sessionsRemoved ? ` (${data.sessionsRemoved} session rows deleted)` : ''
+        showToast(`${label} removed${sessions}`, 'success')
+        await fetchAccounts()
+    } catch {
+        showToast('Failed to connect to server', 'error')
+    }
+}
+
+async function handleCancelScheduledTask(taskId) {
+    if (!confirm('Cancel this scheduled task?')) return
+
+    try {
+        const response = await fetch(`${API_BASE_URL}/schedule/tasks/${taskId}`, {
+            method: 'DELETE'
+        })
+
+        if (response.ok) {
+            scheduledTasks = scheduledTasks.filter(task => task.id !== taskId)
+            saveScheduledTasks()
+            renderScheduledTasks()
+            showToast('Scheduled task cancelled', 'success')
+        } else {
+            showToast('Failed to cancel task', 'error')
+        }
+    } catch {
+        // If API doesn't support cancellation, remove locally
+        scheduledTasks = scheduledTasks.filter(task => task.id !== taskId)
+        saveScheduledTasks()
+        renderScheduledTasks()
+        showToast('Scheduled task cancelled', 'success')
+    }
+}
+
+// Rendering Functions
+function renderAccounts() {
+    if (accounts.length === 0) {
+        accountsList.innerHTML = `
+            <div class="empty-state">
+                <p>No accounts configured. Add an account above to get started.</p>
+            </div>
+        `
+        return
+    }
+
+    accountsList.innerHTML = accounts
+        .map(account => {
+            const isSelected = selectedAccountIndexes.has(account.index)
+            return `
+            <div class="account-card ${isSelected ? 'selected' : ''}" role="listitem">
+                <div class="account-toggle" data-toggle="${account.index}" role="checkbox" tabindex="0"
+                     aria-checked="${isSelected}" aria-label="Select ${escapeHtml(account.email)}">
+                    <input
+                        type="checkbox"
+                        class="account-checkbox"
+                        ${isSelected ? 'checked' : ''}
+                        data-index="${account.index}"
+                        aria-label="Select ${escapeHtml(account.email)}"
+                    >
+                    <div class="account-info">
+                        <div class="account-email">${escapeHtml(account.email)}</div>
+                        <div class="account-meta">
+                            <span>Runs: ${account.runs}</span>
+                            ${account.lastRunAt ? `<span>Last: ${formatDate(account.lastRunAt)}</span>` : ''}
+                            ${account.proxy ? `<span class="account-proxy-badge">${escapeHtml(formatProxyLabel(account.proxy))}</span>` : ''}
+                        </div>
+                    </div>
+                    <div class="account-points">${account.points} pts</div>
+                    <span class="account-status ${account.status}">${formatStatus(account.status)}</span>
+                </div>
+                <button class="btn btn-secondary" data-index="${account.index}" data-action="proxy">Proxy</button>
+                <button class="btn btn-danger" data-index="${account.index}" data-action="delete">Remove</button>
+            </div>
+        `
+        })
+        .join('')
+
+    // Attach event listeners
+    accountsList.querySelectorAll('.account-toggle').forEach(row => {
+        const checkbox = row.querySelector('.account-checkbox')
+        const index = parseInt(row.dataset.toggle)
+
+        // Clicking anywhere in the row toggles it. The checkbox is a real one
+        // underneath for keyboard and screen readers; the label-less wrapper
+        // decides the new state from the checkbox itself, not from the click.
+        row.addEventListener('click', e => {
+            // The Proxy and Remove buttons live outside this wrapper, but guard
+            // anyway so a future nesting mistake cannot swallow their clicks.
+            if (e.target.closest('button')) return
+            handleAccountCheckbox(index, !checkbox.checked)
+        })
+
+        row.addEventListener('keydown', e => {
+            if (e.key !== ' ' && e.key !== 'Enter') return
+            if (e.target !== row) return
+            e.preventDefault()
+            handleAccountCheckbox(index, !checkbox.checked)
+        })
+
+        // The checkbox is inside the row, so its own change event would fire
+        // after the row click already toggled. Stop it double-counting.
+        checkbox.addEventListener('click', e => e.stopPropagation())
+        checkbox.addEventListener('change', e => {
+            handleAccountCheckbox(parseInt(e.target.dataset.index), e.target.checked)
+        })
+    })
+
+    accountsList.querySelectorAll('[data-action="delete"]').forEach(btn => {
+        btn.addEventListener('click', e => {
+            handleDeleteAccount(parseInt(e.target.dataset.index))
+        })
+    })
+
+    accountsList.querySelectorAll('[data-action="proxy"]').forEach(btn => {
+        btn.addEventListener('click', e => {
+            openProxyEditor(parseInt(e.target.dataset.index))
+        })
+    })
+}
+
+function formatProxyLabel(proxy) {
+    const label = `${proxy.url}${proxy.port ? `:${proxy.port}` : ''}`
+    return proxy.hasCredentials ? `${label} (auth)` : label
+}
+
+function updateStats() {
+    const loggedIn = accounts.filter(acc => acc.status === 'logged-in').length
+    const notLoggedIn = accounts.filter(acc => acc.status === 'not-logged-in').length
+    const expired = accounts.filter(acc => acc.status === 'expired').length
+
+    totalAccountsEl.textContent = accounts.length
+    loggedInCountEl.textContent = loggedIn
+    notLoggedInCountEl.textContent = notLoggedIn
+    expiredCountEl.textContent = expired
+}
+
+function renderScheduledTasks() {
+    // Remove expired tasks
+    const now = new Date()
+    scheduledTasks = scheduledTasks.filter(task => new Date(task.scheduledAt) > now)
+    saveScheduledTasks()
+
+    if (scheduledTasks.length === 0) {
+        scheduledList.innerHTML = `
+            <div class="empty-state">
+                <p>No scheduled tasks</p>
+            </div>
+        `
+        return
+    }
+
+    scheduledList.innerHTML = scheduledTasks
+        .sort((a, b) => new Date(a.scheduledAt) - new Date(b.scheduledAt))
+        .map(task => {
+            const scheduledDate = new Date(task.scheduledAt)
+            return `
+            <div class="scheduled-task">
+                <div class="scheduled-info">
+                    <div class="scheduled-time">${scheduledDate.toLocaleString()}</div>
+                    <div class="scheduled-accounts">
+                        ${task.accountEmails.length} account(s): ${task.accountEmails.join(', ')}
+                    </div>
+                    ${task.headless ? '<span class="scheduled-mode">Headless Mode</span>' : ''}
+                </div>
+                <button class="btn btn-danger" data-task-id="${task.id}" data-action="cancel-task">Cancel</button>
+            </div>
+        `
+        })
+        .join('')
+
+    // Attach event listeners
+    scheduledList.querySelectorAll('[data-action="cancel-task"]').forEach(btn => {
+        btn.addEventListener('click', e => {
+            handleCancelScheduledTask(e.target.dataset.taskId)
+        })
+    })
+}
+
+function updateServerStatus(status) {
+    serverStatusEl.dataset.status = status
+    serverStatusEl.textContent = status.charAt(0).toUpperCase() + status.slice(1)
+
+    // Stop only makes sense while something is actually running.
+    stopBtn.disabled = status !== 'running'
+    runSelectedBtn.disabled = status === 'running'
+}
+
+function showToast(message, type = 'success') {
+    toast.textContent = message
+    toast.className = `toast ${type} show`
+
+    setTimeout(() => {
+        toast.classList.remove('show')
+    }, 3000)
+}
+
+// Utility Functions
+function formatStatus(status) {
+    return status
+        .split('-')
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ')
+}
+
+function formatDate(dateString) {
+    if (!dateString) return ''
+    const date = new Date(dateString)
+    const now = new Date()
+    const diff = now - date
+    const hours = Math.floor(diff / (1000 * 60 * 60))
+
+    if (hours < 1) return 'Just now'
+    if (hours < 24) return `${hours}h ago`
+    const days = Math.floor(hours / 24)
+    return `${days}d ago`
+}
+
+function escapeHtml(text) {
+    const div = document.createElement('div')
+    div.textContent = text
+    return div.innerHTML
+}
+
+// LocalStorage
+function saveToLocalStorage() {
+    localStorage.setItem('rewards_accounts', JSON.stringify(accounts))
+}
+
+function loadFromLocalStorage() {
+    const stored = localStorage.getItem('rewards_accounts')
+    if (stored) {
+        try {
+            accounts = JSON.parse(stored)
+        } catch {
+            accounts = []
+        }
+    }
+}
+
+function saveScheduledTasks() {
+    localStorage.setItem('scheduled_tasks', JSON.stringify(scheduledTasks))
+}
+
+function loadScheduledTasks() {
+    const stored = localStorage.getItem('scheduled_tasks')
+    if (stored) {
+        try {
+            scheduledTasks = JSON.parse(stored)
+            renderScheduledTasks()
+        } catch {
+            scheduledTasks = []
+        }
+    }
+}
+
+// Polling
+function startPolling() {
+    setInterval(() => {
+        checkServerHealth()
+    }, POLL_INTERVAL)
+}
diff --git a/public/index.html b/public/index.html
new file mode 100644
index 00000000..c03d8b8c
--- /dev/null
+++ b/public/index.html
@@ -0,0 +1,216 @@
+<!doctype html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>Microsoft Rewards Control</title>
+        <link rel="stylesheet" href="style.css" />
+    </head>
+    <body>
+        <div class="container">
+            <header>
+                <h1>Microsoft Rewards Control</h1>
+                <div class="server-status">
+                    <span class="status-label">Server:</span>
+                    <span class="status-indicator" id="serverStatus" data-status="offline">Offline</span>
+                </div>
+            </header>
+
+            <main>
+                <section class="add-account">
+                    <h2>Add Account</h2>
+                    <form id="addAccountForm" aria-label="Add new account">
+                        <div class="form-group">
+                            <label for="emailInput">Email Address</label>
+                            <input
+                                type="email"
+                                id="emailInput"
+                                name="email"
+                                placeholder="email@example.com"
+                                required
+                                aria-required="true"
+                            />
+                        </div>
+                        <button type="submit" class="btn btn-primary">Add Account</button>
+                    </form>
+                </section>
+
+                <section class="dashboard">
+                    <h2>Account Overview</h2>
+                    <div class="stats-grid">
+                        <div class="stat-card">
+                            <span class="stat-label">Total Accounts</span>
+                            <span class="stat-value" id="totalAccounts">0</span>
+                        </div>
+                        <div class="stat-card">
+                            <span class="stat-label">Logged In</span>
+                            <span class="stat-value" id="loggedInCount">0</span>
+                        </div>
+                        <div class="stat-card">
+                            <span class="stat-label">Not Logged In</span>
+                            <span class="stat-value" id="notLoggedInCount">0</span>
+                        </div>
+                        <div class="stat-card">
+                            <span class="stat-label">Login Expired</span>
+                            <span class="stat-value" id="expiredCount">0</span>
+                        </div>
+                    </div>
+                </section>
+
+                <section class="controls-section">
+                    <h2>Execution Settings</h2>
+                    <div class="controls-grid">
+                        <div class="control-group">
+                            <label class="toggle-label">
+                                <input type="checkbox" id="headlessToggle" class="toggle-input" />
+                                <span class="toggle-switch"></span>
+                                <span class="toggle-text">Run in Headless Mode</span>
+                            </label>
+                            <p class="control-hint">Browser runs hidden without visible window</p>
+                        </div>
+                        <div class="control-group">
+                            <label class="toggle-label">
+                                <input type="checkbox" id="visualSearchToggle" class="toggle-input" />
+                                <span class="toggle-switch"></span>
+                                <span class="toggle-text">Run Visual Search</span>
+                            </label>
+                            <p class="control-hint">Automates Bing Visual Search for daily points</p>
+                        </div>
+                        <div class="control-group">
+                            <label class="toggle-label">
+                                <input type="checkbox" id="edgeBrowsingToggle" class="toggle-input" />
+                                <span class="toggle-switch"></span>
+                                <span class="toggle-text">Run 30-Minute Edge Browsing</span>
+                            </label>
+                            <p class="control-hint">Browses in the background for 30 minutes</p>
+                        </div>
+                        <div class="control-group">
+                            <label for="scheduleTime">Schedule for Later</label>
+                            <input type="datetime-local" id="scheduleTime" class="datetime-input" />
+                            <p class="control-hint">Leave empty to run immediately</p>
+                        </div>
+                    </div>
+                </section>
+
+                <section class="queue-section">
+                    <div class="queue-header">
+                        <h2>Ready to Execute</h2>
+                        <div class="queue-actions">
+                            <button id="selectAllBtn" class="btn btn-secondary">Select All</button>
+                            <button id="runSelectedBtn" class="btn btn-success">Run Selected</button>
+                            <button id="stopBtn" class="btn btn-stop" disabled>Stop</button>
+                            <button id="scheduleSelectedBtn" class="btn btn-primary">Schedule Run</button>
+                        </div>
+                    </div>
+
+                    <div id="accountsList" class="accounts-list" role="list">
+                        <div class="empty-state">
+                            <p>No accounts configured. Add an account above to get started.</p>
+                        </div>
+                    </div>
+                </section>
+
+                <section class="proxy-section">
+                    <h2>Proxy for <span id="proxyAccountEmail">an account</span></h2>
+
+                    <div id="proxyEmpty" class="empty-state">
+                        <p>Select an account above, then click <strong>Proxy</strong> on its row to edit it here.</p>
+                    </div>
+
+                    <form id="proxyForm" hidden aria-label="Edit account proxy">
+                        <div class="proxy-grid">
+                            <div class="form-group proxy-wide">
+                                <label for="proxyUrlInput">Proxy address</label>
+                                <input
+                                    type="text"
+                                    id="proxyUrlInput"
+                                    placeholder="proxy.example.com or socks5://proxy.example.com"
+                                    autocomplete="off"
+                                />
+                                <p class="control-hint">
+                                    Include the scheme (<code>http://</code>, <code>https://</code>,
+                                    <code>socks4://</code>, <code>socks5://</code>). Leave this blank and save to
+                                    disable the proxy for this account.
+                                </p>
+                            </div>
+
+                            <div class="form-group">
+                                <label for="proxyPortInput">Port</label>
+                                <input type="text" id="proxyPortInput" placeholder="8080" autocomplete="off" />
+                                <p class="control-hint">A number from 1 to 65535.</p>
+                            </div>
+
+                            <div class="form-group">
+                                <label for="proxyUsernameInput">Username (optional)</label>
+                                <input type="text" id="proxyUsernameInput" autocomplete="off" />
+                                <p class="control-hint">Not supported for SOCKS proxies.</p>
+                            </div>
+
+                            <div class="form-group">
+                                <label for="proxyPasswordInput">Password (optional)</label>
+                                <input type="password" id="proxyPasswordInput" autocomplete="new-password" />
+                                <p class="control-hint" id="proxyPasswordHint">
+                                    Leave blank to keep the saved password.
+                                </p>
+                            </div>
+
+                            <div class="control-group proxy-wide">
+                                <label class="toggle-label">
+                                    <input type="checkbox" id="proxyHttpToggle" class="toggle-input" />
+                                    <span class="toggle-switch"></span>
+                                    <span class="toggle-text">Use for API requests too</span>
+                                </label>
+                                <p class="control-hint">
+                                    On: the proxy covers both the browser <em>and</em> the direct Rewards API calls.
+                                    Off: the browser uses the proxy, but API calls go out from your own connection.
+                                </p>
+                            </div>
+                        </div>
+
+                        <div class="proxy-actions">
+                            <button type="submit" class="btn btn-primary">Save Proxy</button>
+                            <button type="button" id="proxyCancelBtn" class="btn btn-secondary">Close</button>
+                            <button type="button" id="proxyClearBtn" class="btn btn-danger">Remove Proxy</button>
+                        </div>
+                        <p class="control-hint">Changes are saved to <code>.env</code> and apply to the next run.</p>
+                    </form>
+                </section>
+
+                <section class="scheduled-section">
+                    <h2>Scheduled Tasks</h2>
+                    <div id="scheduledList" class="scheduled-list">
+                        <div class="empty-state">
+                            <p>No scheduled tasks</p>
+                        </div>
+                    </div>
+                </section>
+
+                <section class="logs-section">
+                    <div class="logs-header">
+                        <h2>Live Logs</h2>
+                        <div class="logs-controls">
+                            <label class="toggle-label">
+                                <input type="checkbox" id="autoScrollToggle" class="toggle-input" checked />
+                                <span class="toggle-switch"></span>
+                                <span class="toggle-text">Auto-scroll</span>
+                            </label>
+                            <button id="clearLogsBtn" class="btn btn-secondary">Clear</button>
+                        </div>
+                    </div>
+                    <div
+                        id="logsConsole"
+                        class="logs-console"
+                        role="log"
+                        aria-live="polite"
+                        aria-label="Live bot logs"
+                        tabindex="0"
+                    ></div>
+                </section>
+            </main>
+        </div>
+
+        <div id="toast" class="toast" role="alert" aria-live="polite"></div>
+
+        <script src="app.js"></script>
+    </body>
+</html>
diff --git a/public/style.css b/public/style.css
new file mode 100644
index 00000000..ac83fe26
--- /dev/null
+++ b/public/style.css
@@ -0,0 +1,697 @@
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+:root {
+    --bg-primary: #0f1117;
+    --bg-secondary: #171a23;
+    --bg-tertiary: #1e222e;
+    --accent: #5b8cff;
+    --accent-hover: #4a7aeb;
+    --text-primary: #ffffff;
+    --text-secondary: #a0a0a0;
+    --border: #2a2e3a;
+    --success: #10b981;
+    --warning: #f59e0b;
+    --error: #ef4444;
+    --radius: 8px;
+    --spacing: 1.5rem;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    line-height: 1.6;
+    min-height: 100vh;
+}
+
+.container {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: var(--spacing);
+}
+
+header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: calc(var(--spacing) * 2);
+    padding-bottom: var(--spacing);
+    border-bottom: 1px solid var(--border);
+}
+
+h1 {
+    font-size: 1.75rem;
+    font-weight: 600;
+}
+
+h2 {
+    font-size: 1.25rem;
+    font-weight: 600;
+    margin-bottom: 1rem;
+}
+
+.server-status {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.status-label {
+    color: var(--text-secondary);
+    font-size: 0.875rem;
+}
+
+.status-indicator {
+    padding: 0.25rem 0.75rem;
+    border-radius: 20px;
+    font-size: 0.875rem;
+    font-weight: 500;
+}
+
+.status-indicator[data-status='online'] {
+    background: rgba(16, 185, 129, 0.2);
+    color: var(--success);
+}
+
+.status-indicator[data-status='offline'] {
+    background: rgba(239, 68, 68, 0.2);
+    color: var(--error);
+}
+
+.status-indicator[data-status='running'] {
+    background: rgba(245, 158, 11, 0.2);
+    color: var(--warning);
+}
+
+section {
+    background: var(--bg-secondary);
+    padding: var(--spacing);
+    border-radius: var(--radius);
+    margin-bottom: var(--spacing);
+}
+
+.form-group {
+    margin-bottom: 1rem;
+}
+
+label {
+    display: block;
+    margin-bottom: 0.5rem;
+    font-weight: 500;
+    color: var(--text-primary);
+}
+
+input[type='email'],
+input[type='text'] {
+    width: 100%;
+    padding: 0.75rem;
+    background: var(--bg-tertiary);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    color: var(--text-primary);
+    font-size: 1rem;
+    transition: border-color 0.2s;
+}
+
+input:focus {
+    outline: none;
+    border-color: var(--accent);
+}
+
+input::placeholder {
+    color: var(--text-secondary);
+}
+
+.btn {
+    padding: 0.75rem 1.5rem;
+    border: none;
+    border-radius: var(--radius);
+    font-size: 1rem;
+    font-weight: 500;
+    cursor: pointer;
+    transition:
+        background-color 0.2s,
+        transform 0.1s;
+}
+
+.btn:hover {
+    transform: translateY(-1px);
+}
+
+.btn:active {
+    transform: translateY(0);
+}
+
+.btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+    transform: none;
+}
+
+.btn-primary {
+    background: var(--accent);
+    color: white;
+}
+
+.btn-primary:hover:not(:disabled) {
+    background: var(--accent-hover);
+}
+
+.btn-secondary {
+    background: var(--bg-tertiary);
+    color: var(--text-primary);
+    border: 1px solid var(--border);
+}
+
+.btn-secondary:hover:not(:disabled) {
+    background: var(--border);
+}
+
+.btn-success {
+    background: var(--success);
+    color: white;
+}
+
+.btn-success:hover:not(:disabled) {
+    background: #0fa073;
+}
+
+.btn-danger {
+    background: var(--error);
+    color: white;
+    padding: 0.5rem 1rem;
+    font-size: 0.875rem;
+}
+
+.btn-danger:hover:not(:disabled) {
+    background: #dc2626;
+}
+
+.btn-stop {
+    background: var(--error);
+    color: white;
+}
+
+.btn-stop:hover:not(:disabled) {
+    background: #dc2626;
+}
+
+.stats-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 1rem;
+}
+
+.stat-card {
+    background: var(--bg-tertiary);
+    padding: 1.25rem;
+    border-radius: var(--radius);
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.stat-label {
+    color: var(--text-secondary);
+    font-size: 0.875rem;
+}
+
+.stat-value {
+    font-size: 2rem;
+    font-weight: 600;
+}
+
+.queue-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1rem;
+}
+
+.queue-actions {
+    display: flex;
+    gap: 0.75rem;
+}
+
+.accounts-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.75rem;
+}
+
+.empty-state {
+    text-align: center;
+    padding: 3rem 1rem;
+    color: var(--text-secondary);
+}
+
+.account-card {
+    background: var(--bg-tertiary);
+    padding: 1rem;
+    border-radius: var(--radius);
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+    border: 2px solid transparent;
+    transition: border-color 0.2s;
+}
+
+.account-card:hover {
+    border-color: var(--border);
+}
+
+.account-card.selected {
+    border-color: var(--accent);
+}
+
+/* Click target: everything in the row except the Proxy and Remove buttons. */
+.account-toggle {
+    flex: 1;
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+    cursor: pointer;
+    border-radius: var(--radius);
+    min-width: 0;
+}
+
+.account-toggle:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 4px;
+}
+
+@media (max-width: 768px) {
+    .account-toggle {
+        flex-direction: column;
+        align-items: flex-start;
+    }
+}
+
+.account-checkbox {
+    width: 20px;
+    height: 20px;
+    cursor: pointer;
+    accent-color: var(--accent);
+    flex-shrink: 0;
+}
+
+.account-info {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+}
+
+.account-email {
+    font-weight: 500;
+    font-size: 1rem;
+}
+
+.account-meta {
+    display: flex;
+    gap: 1rem;
+    font-size: 0.875rem;
+    color: var(--text-secondary);
+}
+
+.account-points {
+    font-size: 1.25rem;
+    font-weight: 600;
+    color: var(--accent);
+}
+
+.account-status {
+    padding: 0.25rem 0.75rem;
+    border-radius: 20px;
+    font-size: 0.75rem;
+    font-weight: 500;
+}
+
+.account-status.logged-in {
+    background: rgba(16, 185, 129, 0.2);
+    color: var(--success);
+}
+
+.account-status.not-logged-in {
+    background: rgba(239, 68, 68, 0.2);
+    color: var(--error);
+}
+
+.account-status.expired {
+    background: rgba(245, 158, 11, 0.2);
+    color: var(--warning);
+}
+
+.account-status.running {
+    background: rgba(91, 140, 255, 0.2);
+    color: var(--accent);
+}
+
+.account-proxy-badge {
+    color: var(--accent);
+    font-size: 0.75rem;
+}
+
+.proxy-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+    gap: 1rem;
+    margin-bottom: 1rem;
+}
+
+.proxy-wide {
+    grid-column: 1 / -1;
+}
+
+.proxy-actions {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.75rem;
+    margin-bottom: 0.75rem;
+}
+
+.proxy-section code {
+    background: var(--bg-primary);
+    padding: 0.1rem 0.35rem;
+    border-radius: 4px;
+    font-size: 0.85em;
+}
+
+input[type='password'] {
+    width: 100%;
+    padding: 0.75rem;
+    background: var(--bg-tertiary);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    color: var(--text-primary);
+    font-size: 1rem;
+    transition: border-color 0.2s;
+}
+
+.toast {
+    position: fixed;
+    bottom: 2rem;
+    right: 2rem;
+    background: var(--bg-tertiary);
+    color: var(--text-primary);
+    padding: 1rem 1.5rem;
+    border-radius: var(--radius);
+    border: 1px solid var(--border);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.4);
+    transform: translateY(120%);
+    transition: transform 0.3s;
+    z-index: 1000;
+    max-width: 400px;
+}
+
+.toast.show {
+    transform: translateY(0);
+}
+
+.toast.success {
+    border-color: var(--success);
+}
+
+.toast.error {
+    border-color: var(--error);
+}
+
+.toast.warning {
+    border-color: var(--warning);
+}
+
+.controls-section {
+    background: var(--bg-secondary);
+    padding: var(--spacing);
+    border-radius: var(--radius);
+    margin-bottom: var(--spacing);
+}
+
+.controls-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+    gap: 1.5rem;
+}
+
+.control-group {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.control-hint {
+    font-size: 0.875rem;
+    color: var(--text-secondary);
+    margin: 0;
+}
+
+.toggle-label {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    cursor: pointer;
+}
+
+.toggle-input {
+    display: none;
+}
+
+.toggle-switch {
+    position: relative;
+    width: 48px;
+    height: 24px;
+    background: var(--bg-tertiary);
+    border-radius: 20px;
+    border: 1px solid var(--border);
+    transition: background-color 0.3s;
+}
+
+.toggle-switch::after {
+    content: '';
+    position: absolute;
+    top: 2px;
+    left: 2px;
+    width: 18px;
+    height: 18px;
+    background: var(--text-secondary);
+    border-radius: 50%;
+    transition:
+        transform 0.3s,
+        background-color 0.3s;
+}
+
+.toggle-input:checked + .toggle-switch {
+    background: var(--accent);
+}
+
+.toggle-input:checked + .toggle-switch::after {
+    transform: translateX(24px);
+    background: white;
+}
+
+.toggle-text {
+    font-weight: 500;
+    font-size: 1rem;
+}
+
+.datetime-input {
+    padding: 0.75rem;
+    background: var(--bg-tertiary);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    color: var(--text-primary);
+    font-size: 1rem;
+    transition: border-color 0.2s;
+}
+
+.datetime-input:focus {
+    outline: none;
+    border-color: var(--accent);
+}
+
+.datetime-input::-webkit-calendar-picker-indicator {
+    filter: invert(1);
+    cursor: pointer;
+}
+
+.scheduled-section {
+    background: var(--bg-secondary);
+    padding: var(--spacing);
+    border-radius: var(--radius);
+}
+
+.scheduled-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.75rem;
+}
+
+.scheduled-task {
+    background: var(--bg-tertiary);
+    padding: 1rem;
+    border-radius: var(--radius);
+    display: grid;
+    grid-template-columns: 1fr auto;
+    gap: 1rem;
+    align-items: center;
+}
+
+.scheduled-info {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+}
+
+.scheduled-time {
+    font-weight: 600;
+    font-size: 1rem;
+}
+
+.scheduled-accounts {
+    font-size: 0.875rem;
+    color: var(--text-secondary);
+}
+
+.scheduled-mode {
+    font-size: 0.75rem;
+    padding: 0.25rem 0.5rem;
+    border-radius: 4px;
+    background: rgba(91, 140, 255, 0.2);
+    color: var(--accent);
+    display: inline-block;
+}
+
+.logs-section {
+    background: var(--bg-secondary);
+    padding: var(--spacing);
+    border-radius: var(--radius);
+}
+
+.logs-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1rem;
+    gap: 1rem;
+    flex-wrap: wrap;
+}
+
+.logs-controls {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+}
+
+.logs-console {
+    background: #0b0d12;
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 1rem;
+    height: 320px;
+    overflow-y: auto;
+    font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;
+    font-size: 0.8125rem;
+    line-height: 1.5;
+    white-space: pre-wrap;
+    word-break: break-word;
+}
+
+.logs-console:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+}
+
+.log-line {
+    display: flex;
+    gap: 0.75rem;
+}
+
+.log-line + .log-line {
+    margin-top: 0.125rem;
+}
+
+.log-time {
+    color: #5a6270;
+    flex-shrink: 0;
+}
+
+.log-level {
+    flex-shrink: 0;
+    font-weight: 600;
+    width: 3.5rem;
+}
+
+.log-message {
+    color: var(--text-primary);
+}
+
+.log-line[data-level='debug'] .log-level,
+.log-line[data-level='debug'] .log-message {
+    color: var(--text-secondary);
+}
+
+.log-line[data-level='info'] .log-level {
+    color: var(--accent);
+}
+
+.log-line[data-level='warn'] .log-level,
+.log-line[data-level='warn'] .log-message {
+    color: var(--warning);
+}
+
+.log-line[data-level='error'] .log-level,
+.log-line[data-level='error'] .log-message {
+    color: var(--error);
+}
+
+.log-empty {
+    color: var(--text-secondary);
+}
+
+@media (max-width: 768px) {
+    .container {
+        padding: 1rem;
+    }
+
+    header {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 1rem;
+    }
+
+    .queue-header {
+        flex-direction: column;
+        align-items: stretch;
+        gap: 1rem;
+    }
+
+    .queue-actions {
+        flex-direction: column;
+    }
+
+    .stats-grid {
+        grid-template-columns: 1fr;
+    }
+
+    .account-card {
+        flex-direction: column;
+        align-items: flex-start;
+    }
+
+    .account-meta {
+        flex-direction: column;
+        gap: 0.25rem;
+    }
+
+    .controls-grid {
+        grid-template-columns: 1fr;
+    }
+
+    .scheduled-task {
+        grid-template-columns: 1fr;
+    }
+}
diff --git a/scripts/api/accountProxy.js b/scripts/api/accountProxy.js
new file mode 100644
index 00000000..529cc412
--- /dev/null
+++ b/scripts/api/accountProxy.js
@@ -0,0 +1,174 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+// Per-account proxy editing for the Web UI. Mirrors the rules the bot enforces
+// in src/util/Validator.ts (AccountProxySchema) and src/util/Proxy.ts, so a
+// proxy saved through the API can never make the next run fail validation.
+// Stored as ACCOUNT_N_PROXY_* lines in .env; the password is never returned.
+
+const PROXY_PROTOCOLS = ['http', 'https', 'socks4', 'socks5']
+const TRUE_WORDS = ['1', 'true', 'yes', 'on']
+
+function badRequest(message) {
+    return Object.assign(new Error(message), { code: 'BAD_REQUEST' })
+}
+
+function envFilePath(projectRoot) {
+    return path.join(projectRoot, '.env')
+}
+
+function accountPrefix(index) {
+    return `ACCOUNT_${index}_`
+}
+
+// Same acceptance rules as src/util/Proxy.ts: a bare hostname means http://.
+export function parseProxyUrl(value) {
+    const input = String(value ?? '').trim()
+    if (!input) throw badRequest('Proxy URL is empty')
+
+    let url
+    try {
+        url = new URL(/^[a-z][a-z\d+.-]*:\/\//i.test(input) ? input : `http://${input}`)
+    } catch {
+        throw badRequest(`Invalid proxy URL: ${value}`)
+    }
+
+    const protocol = url.protocol.toLowerCase().slice(0, -1)
+    if (!PROXY_PROTOCOLS.includes(protocol)) {
+        throw badRequest(`Unsupported proxy protocol "${protocol}"; supported: ${PROXY_PROTOCOLS.join(', ')}`)
+    }
+    if (!url.hostname) throw badRequest(`Invalid proxy URL: ${value}`)
+    return url
+}
+
+function parseEnvFile(projectRoot) {
+    const file = envFilePath(projectRoot)
+    if (!fs.existsSync(file)) return []
+    return fs.readFileSync(file, 'utf8').split(/\r?\n/)
+}
+
+function activeValue(line) {
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith('#')) return null
+    const eq = trimmed.indexOf('=')
+    if (eq === -1) return null
+    const key = trimmed.slice(0, eq).trim()
+    let value = trimmed.slice(eq + 1).trim()
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1)
+    }
+    return { key, value }
+}
+
+export function readAccountProxy(projectRoot, index) {
+    const prefix = accountPrefix(index)
+    const raw = { PROXY_HTTP: 'false', PROXY_URL: '', PROXY_PORT: '0', PROXY_USERNAME: '', PROXY_PASSWORD: '' }
+
+    for (const line of parseEnvFile(projectRoot)) {
+        const entry = activeValue(line)
+        if (!entry || !entry.key.startsWith(prefix)) continue
+        const suffix = entry.key.slice(prefix.length)
+        if (suffix in raw) raw[suffix] = entry.value
+    }
+
+    return {
+        proxyHttp: TRUE_WORDS.includes(raw.PROXY_HTTP.trim().toLowerCase()),
+        url: raw.PROXY_URL,
+        port: Number.parseInt(raw.PROXY_PORT, 10) || 0,
+        username: raw.PROXY_USERNAME,
+        hasPassword: raw.PROXY_PASSWORD.length > 0
+    }
+}
+
+/**
+ * Validates a PUT body against the same rules AccountProxySchema enforces.
+ * A blank password keeps the stored one (returns password: null) as long as
+ * the username is unchanged, so the UI never has to echo secrets back.
+ */
+export function validateProxyInput(body, existing = {}) {
+    if (typeof body !== 'object' || body === null || Array.isArray(body)) {
+        throw badRequest('Body must be a JSON object.')
+    }
+
+    const url = String(body.url ?? '').trim()
+    const proxyHttp = Boolean(body.proxyHttp)
+    const username = String(body.username ?? '').trim()
+    const rawPassword = body.password == null ? '' : String(body.password)
+    const portGiven = body.port !== undefined && body.port !== null && body.port !== ''
+
+    if (!url) {
+        const port = portGiven ? Number(body.port) : 0
+        if (proxyHttp || username || rawPassword || (portGiven && port !== 0)) {
+            throw badRequest('Proxy URL is required when other proxy settings are configured')
+        }
+        return { proxyHttp: false, url: '', port: 0, username: '', password: '' }
+    }
+
+    const parsed = parseProxyUrl(url)
+    if (parsed.username || parsed.password) {
+        throw badRequest('Put proxy credentials in the username/password fields, not in the proxy URL')
+    }
+
+    const port = Number(body.port)
+    if (!portGiven || !Number.isInteger(port) || port < 1 || port > 65535) {
+        throw badRequest('Proxy port must be an integer from 1 to 65535')
+    }
+
+    const keepStored = rawPassword === '' && existing.hasPassword && existing.username === username
+    const password = keepStored ? null : rawPassword
+    const hasPassword = password === null ? true : password.length > 0
+
+    if (Boolean(username) !== hasPassword) {
+        throw badRequest('Proxy username and password must be configured together')
+    }
+
+    const protocol = parsed.protocol.slice(0, -1)
+    if ((protocol === 'socks4' || protocol === 'socks5') && (username || hasPassword)) {
+        throw badRequest(`${protocol.toUpperCase()} proxy authentication is not supported by Patchright`)
+    }
+
+    return { proxyHttp, url: `${parsed.protocol}//${parsed.hostname}`, port, username, password }
+}
+
+export function writeAccountProxy(projectRoot, index, proxy) {
+    const prefix = accountPrefix(index)
+    const lines = parseEnvFile(projectRoot)
+
+    // password: null means "keep whatever is already stored".
+    let password = proxy.password
+    if (password === null) {
+        password = ''
+        for (const line of lines) {
+            const entry = activeValue(line)
+            if (entry?.key === `${prefix}PROXY_PASSWORD`) password = entry.value
+        }
+    }
+
+    const block = [
+        `${prefix}PROXY_HTTP=${proxy.proxyHttp}`,
+        `${prefix}PROXY_URL=${proxy.url}`,
+        `${prefix}PROXY_PORT=${proxy.port}`,
+        `${prefix}PROXY_USERNAME=${proxy.username}`,
+        `${prefix}PROXY_PASSWORD=${password}`
+    ]
+
+    // Replace active PROXY_* lines in place; commented examples stay untouched.
+    let insertAt = -1
+    const kept = []
+    for (const line of lines) {
+        const entry = activeValue(line)
+        if (entry && entry.key.startsWith(`${prefix}PROXY_`)) {
+            if (insertAt === -1) insertAt = kept.length
+            continue
+        }
+        kept.push(line)
+    }
+    if (insertAt === -1) insertAt = kept.length
+    kept.splice(insertAt, 0, ...block)
+
+    const file = envFilePath(projectRoot)
+    const tmp = `${file}.${process.pid}.tmp`
+    fs.writeFileSync(tmp, kept.join('\n'))
+    fs.renameSync(tmp, file)
+    return file
+}
diff --git a/scripts/api/envAccounts.js b/scripts/api/envAccounts.js
new file mode 100644
index 00000000..279d9a19
--- /dev/null
+++ b/scripts/api/envAccounts.js
@@ -0,0 +1,100 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+import { accountIndexesFromEnv } from '../env.js'
+
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+
+function envFilePath(projectRoot) {
+    return path.join(projectRoot, '.env')
+}
+
+// Re-parse .env from disk into process.env so the long-lived API server sees
+// accounts added after it started. ACCOUNT_* keys are overwritten (not skipped
+// like on first boot) because the file is the source of truth for them.
+export function reloadEnvAccounts(projectRoot) {
+    const file = envFilePath(projectRoot)
+    if (!fs.existsSync(file)) return
+
+    for (const key of Object.keys(process.env)) {
+        if (/^ACCOUNT_\d+_/.test(key)) delete process.env[key]
+    }
+
+    for (const line of fs.readFileSync(file, 'utf8').split(/\r?\n/)) {
+        const trimmed = line.trim()
+        if (!trimmed || trimmed.startsWith('#')) continue
+        const eq = trimmed.indexOf('=')
+        if (eq === -1) continue
+        const key = trimmed.slice(0, eq).trim()
+        if (!/^ACCOUNT_\d+_/.test(key)) continue
+        let value = trimmed.slice(eq + 1).trim()
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1)
+        }
+        process.env[key] = value
+    }
+}
+
+// Removes every ACCOUNT_N_* line for one index - the email and any proxy block -
+// leaving the file otherwise intact. The index is never recycled: addAccountToEnv
+// picks max(existing) + 1, so the next account added after a removal gets a fresh
+// number rather than inheriting the session cookies of the deleted one.
+export function removeAccountFromEnv(projectRoot, index) {
+    const i = Number(index)
+    if (!Number.isSafeInteger(i) || i < 1) {
+        throw Object.assign(new Error('A positive account index is required.'), { code: 'BAD_REQUEST' })
+    }
+
+    reloadEnvAccounts(projectRoot)
+    if (!process.env[`ACCOUNT_${i}_EMAIL`]) {
+        throw Object.assign(new Error(`ACCOUNT_${i} is not configured.`), { code: 'UNKNOWN_ACCOUNT' })
+    }
+
+    const file = envFilePath(projectRoot)
+    const prefix = `ACCOUNT_${i}_`
+    const before = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : ''
+    const lines = before.split(/\r?\n/)
+    // Keep one trailing empty line so the file still ends with a newline.
+    const kept = lines.filter(line => {
+        const trimmed = line.trim()
+        if (!trimmed || trimmed.startsWith('#')) return true
+        const eq = trimmed.indexOf('=')
+        return eq === -1 || !trimmed.slice(0, eq).trim().startsWith(prefix)
+    })
+
+    const tmp = `${file}.${process.pid}.tmp`
+    fs.writeFileSync(tmp, kept.join('\n'))
+    fs.renameSync(tmp, file)
+
+    reloadEnvAccounts(projectRoot)
+    return { index: i, envPath: file }
+}
+
+export function addAccountToEnv(projectRoot, email) {
+    const normalized = String(email ?? '').trim()
+    if (!normalized || normalized.length > 320 || !EMAIL_RE.test(normalized)) {
+        throw Object.assign(new Error('A valid email address is required.'), { code: 'BAD_REQUEST' })
+    }
+
+    reloadEnvAccounts(projectRoot)
+
+    const existing = accountIndexesFromEnv().find(
+        i => process.env[`ACCOUNT_${i}_EMAIL`]?.toLowerCase() === normalized.toLowerCase()
+    )
+    if (existing) {
+        throw Object.assign(new Error(`${normalized} is already configured as ACCOUNT_${existing}.`), {
+            code: 'DUPLICATE'
+        })
+    }
+
+    const used = accountIndexesFromEnv()
+    const index = used.length ? Math.max(...used) + 1 : 1
+
+    const file = envFilePath(projectRoot)
+    const before = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : ''
+    const separator = before.length === 0 || before.endsWith('\n') ? '' : '\n'
+    fs.appendFileSync(file, `${separator}\nACCOUNT_${index}_EMAIL=${normalized}\n`, 'utf8')
+
+    process.env[`ACCOUNT_${index}_EMAIL`] = normalized
+    return { index, email: normalized, envPath: file }
+}
diff --git a/scripts/api/logParser.js b/scripts/api/logParser.js
index 2c6bada6..ec5a8c00 100644
--- a/scripts/api/logParser.js
+++ b/scripts/api/logParser.js
@@ -33,7 +33,7 @@ export function parseLogLine(rawInput, source = 'stdout') {
 
     let level = source === 'stderr' ? 'error' : 'info'
     if (/\b(ERROR|Error:|ERR!|FATAL|Traceback|Unhandled)\b/.test(raw)) level = 'error'
-    else if (/\b(WARN|WARNING|Deprecat)/i.test(raw)) level = 'warn'
+    else if (/(WARN|WARNING|Deprecat|ExperimentalWarning)/i.test(raw)) level = 'warn'
 
     return {
         ts: null,
diff --git a/scripts/api/processManager.js b/scripts/api/processManager.js
index 9560f7a0..589cb3e3 100644
--- a/scripts/api/processManager.js
+++ b/scripts/api/processManager.js
@@ -5,6 +5,12 @@ import { parseLogLine, createRunState, applyLogToRunState, summarizeRunState, se
 
 const IS_WIN = process.platform === 'win32'
 
+// Written to the child's stdin to request a graceful abort. Windows has no real
+// SIGTERM for child processes, so a signal would just be TerminateProcess and the
+// bot could never close its browsers; this gives it a cross-platform way to hear
+// "stop" and unwind before we escalate to killing the tree.
+export const ABORT_SENTINEL = '__ABORT__'
+
 const BLOCKED_ENV = new Set([
     'NODE_OPTIONS',
     'NODE_PATH',
@@ -82,7 +88,7 @@ export class ProcessManager extends EventEmitter {
             child = spawn(this.command, args, {
                 cwd: this.cwd,
                 env,
-                stdio: ['ignore', 'pipe', 'pipe'],
+                stdio: ['pipe', 'pipe', 'pipe'],
                 detached: !IS_WIN, // own process group on POSIX so we can signal the whole tree
                 windowsHide: true
             })
@@ -128,9 +134,17 @@ export class ProcessManager extends EventEmitter {
         const wasStopping = this.state === 'stopping'
         this.state = 'stopping'
         if (!wasStopping) {
-            this._controllerLog('warn', force ? 'Force-stopping run (SIGKILL)…' : 'Stopping run (SIGTERM)…')
             this._emitStatus('stopping')
-            this._killTree(force ? 'SIGKILL' : 'SIGTERM')
+
+            if (force) {
+                this._controllerLog('warn', 'Force-stopping run - killing the browser process tree…')
+                this._killTree('SIGKILL')
+            } else {
+                // Ask the bot to abort and close its browsers itself; _killTimer
+                // escalates to a tree kill if it does not exit in time.
+                this._controllerLog('warn', 'Stopping run - asking the bot to abort and close browsers…')
+                this._requestAbort()
+            }
 
             this._killTimer = setTimeout(() => {
                 if (this.state !== 'idle') {
@@ -339,6 +353,19 @@ export class ProcessManager extends EventEmitter {
         this.emit('status', { reason, ...this.getStatus() })
     }
 
+    /**
+     * Ask the bot to abort gracefully: sentinel on stdin (works on Windows) plus
+     * SIGTERM on POSIX, where the bot's own handler is the faster path.
+     */
+    _requestAbort() {
+        try {
+            this.child?.stdin?.write(`${ABORT_SENTINEL}\n`)
+        } catch {
+            // stdin already closed - the signal / kill timer still covers us
+        }
+        if (!IS_WIN) this._killTree('SIGTERM')
+    }
+
     _killTree(signal) {
         if (!this.child || this.pid == null) return
         try {
diff --git a/scripts/api/server.js b/scripts/api/server.js
index 32302fd1..f16a9164 100644
--- a/scripts/api/server.js
+++ b/scripts/api/server.js
@@ -4,8 +4,22 @@ import path from 'node:path'
 import crypto from 'node:crypto'
 import { fileURLToPath } from 'node:url'
 
+const MIME_TYPES = {
+    '.html': 'text/html; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.js': 'application/javascript; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon'
+}
+
 import { ProcessManager } from './processManager.js'
 import { buildExcludedAccountsEnv, buildSingleAccountEnv, loadAccounts, mergeAccountStats } from './accounts.js'
+import { addAccountToEnv, reloadEnvAccounts, removeAccountFromEnv } from './envAccounts.js'
+import { readAccountProxy, validateProxyInput, writeAccountProxy } from './accountProxy.js'
 import {
     validateConfig,
     deepMerge,
@@ -15,7 +29,9 @@ import {
     syncMissingDefaults
 } from './configEditor.js'
 import { readSchedule, writeSchedule } from './scheduleStore.js'
-import { deleteStoredSessions, listStoredSessions } from './sessionStore.js'
+import { readScheduledTasks, addScheduledTask, removeScheduledTask } from './taskScheduler.js'
+import { TaskRunner } from './taskRunner.js'
+import { deleteStoredSessions, getSessionLoginStatusMap, listStoredSessions } from './sessionStore.js'
 import { resolveRunCommand } from './runCommand.js'
 import {
     log,
@@ -31,6 +47,7 @@ import {
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const projectRoot = getProjectRoot(__dirname)
+const publicDir = path.join(projectRoot, 'public')
 
 loadEnvFile(projectRoot)
 
@@ -110,7 +127,7 @@ const TOKEN = envStr('API_TOKEN') ?? (typeof cliArgs.token === 'string' ? cliArg
 const CORS_ORIGIN = envStr('API_CORS_ORIGIN') ?? '*'
 const LOG_BUFFER = integerSetting('API_LOG_BUFFER', envStr('API_LOG_BUFFER'), 2000)
 const STOP_TIMEOUT_MS = integerSetting('API_STOP_TIMEOUT_MS', envStr('API_STOP_TIMEOUT_MS'), 15000)
-const ALLOW_ENV_OVERRIDES = envBool('API_ALLOW_ENV_OVERRIDES', false)
+const ALLOW_ENV_OVERRIDES = envBool('API_ALLOW_ENV_OVERRIDES', true)
 const REVEAL_ENABLED = envBool('API_ALLOW_CONFIG_REVEAL', false)
 const ALLOW_CONFIG_WRITE = envBool('API_ALLOW_CONFIG_WRITE', false)
 const ALLOW_SCHEDULE_WRITE = envBool('API_ALLOW_SCHEDULE_WRITE', false)
@@ -133,6 +150,39 @@ const pm = new ProcessManager({
 
 const startedAt = Date.now()
 
+/**
+ * Turns a scheduled task into the env a run needs: the account selection is
+ * expressed as exclusions (same shape the /start endpoint uses) and the headless
+ * flag rides along as a CONFIG_* override.
+ */
+function buildEnvForTask(task) {
+    reloadEnvAccounts(projectRoot)
+
+    const wanted = new Set((task.accountIndexes ?? []).map(Number))
+    if (!wanted.size) {
+        const err = new Error('Task has no accounts selected.')
+        err.code = 'BAD_REQUEST'
+        throw err
+    }
+
+    const configured = loadAccounts()
+    if (!configured.length) {
+        const err = new Error('No accounts are configured in .env.')
+        err.code = 'BAD_REQUEST'
+        throw err
+    }
+
+    const excluded = configured.map(account => account.index).filter(index => !wanted.has(index))
+    const env = excluded.length ? buildExcludedAccountsEnv(excluded).env : {}
+
+    if (task.headless != null) env.CONFIG_HEADLESS = String(Boolean(task.headless))
+    if (task.visualSearch != null) env.CONFIG_WORKER_VISUAL_SEARCH = String(Boolean(task.visualSearch))
+    if (task.edgeBrowsing != null) env.CONFIG_EXPERIMENTAL_EDGE_BROWSING = String(Boolean(task.edgeBrowsing))
+    return env
+}
+
+const taskRunner = new TaskRunner({ projectRoot, pm, buildEnvForTask })
+
 function containsControlCharacters(value) {
     return [...value].some(character => {
         const code = character.charCodeAt(0)
@@ -140,6 +190,20 @@ function containsControlCharacters(value) {
     })
 }
 
+// Session rows are keyed by email, so an orphaned one survives the account being
+// removed from .env and would attach to whoever inherits that index later.
+function deleteSessionsForEmail(projectRoot, email) {
+    const loaded = loadConfigSafe(projectRoot)
+    const sessionPath =
+        loaded?.data && typeof loaded.data.sessionPath === 'string' ? loaded.data.sessionPath : 'sessions'
+    try {
+        return deleteStoredSessions(projectRoot, sessionPath, email)
+    } catch {
+        // A locked or corrupt session DB must not block the .env removal itself.
+        return { found: false, removed: 0 }
+    }
+}
+
 if (containsControlCharacters(HOST) || containsControlCharacters(CORS_ORIGIN)) {
     log('ERROR', 'API_HOST and API_CORS_ORIGIN must not contain control characters.')
     process.exit(1)
@@ -333,6 +397,16 @@ const requestHandler = async (req, res) => {
     try {
         // index
         if (method === 'GET' && pathname === '/') {
+            return serveStaticFile(res, pathname)
+        }
+
+        // Serve static files from public directory
+        if (method === 'GET' && (pathname.endsWith('.html') || pathname.endsWith('.css') || pathname.endsWith('.js'))) {
+            return serveStaticFile(res, pathname)
+        }
+
+        // API index
+        if (method === 'GET' && pathname === '/api') {
             return sendJson(res, 200, {
                 name: pkgName,
                 version: pkgVersion,
@@ -347,6 +421,10 @@ const requestHandler = async (req, res) => {
                     'GET /errors',
                     'GET /history',
                     'GET /accounts',
+                    'POST /accounts',
+                    'DELETE /accounts/:index',
+                    'GET /accounts/:index/proxy',
+                    'PUT /accounts/:index/proxy',
                     'GET /sessions',
                     'GET /diagnostics',
                     'GET /events',
@@ -419,12 +497,122 @@ const requestHandler = async (req, res) => {
             return sendJson(res, 200, { runs, count: runs.length, inMemoryOnly: true })
         }
 
-        // account overview
+        // account overview — enriched with real session auth state so the badge
+        // reflects live cookies, not stale in-memory run history.
         if (method === 'GET' && pathname === '/accounts') {
+            reloadEnvAccounts(projectRoot)
             const accounts = mergeAccountStats(loadAccounts(), pm.getHistory().map(toHistoryRecord))
+            const loaded = loadConfigSafe(projectRoot)
+            const sessionPath =
+                loaded?.data && typeof loaded.data.sessionPath === 'string' ? loaded.data.sessionPath : 'sessions'
+            const sessionMap = getSessionLoginStatusMap(projectRoot, sessionPath)
+            if (sessionMap) {
+                for (const account of accounts) {
+                    const info = sessionMap.get(account.email.toLowerCase()) ?? null
+                    if (info) {
+                        account.sessionStatus = info.status
+                        account.sessionUpdatedAt = info.updatedAt
+                        account.sessionLiveAuthCookieCount = info.liveAuthCookieCount
+                        account.sessionNextAuthExpiry = info.nextAuthExpiry
+                    } else {
+                        account.sessionStatus = 'not-logged-in'
+                        account.sessionUpdatedAt = null
+                        account.sessionLiveAuthCookieCount = 0
+                        account.sessionNextAuthExpiry = null
+                    }
+                }
+            }
             return sendJson(res, 200, { accounts, count: accounts.length })
         }
 
+        // per-account proxy - read
+        if (method === 'GET' && /^\/accounts\/\d+\/proxy$/.test(pathname)) {
+            const index = Number(pathname.split('/')[2])
+            const known = new Set(loadAccounts().map(account => account.index))
+            if (!known.has(index)) {
+                return sendJson(res, 404, { error: `ACCOUNT_${index} is not configured.`, code: 'UNKNOWN_ACCOUNT' })
+            }
+            return sendJson(res, 200, { index, proxy: readAccountProxy(projectRoot, index) })
+        }
+
+        // per-account proxy - write; always edits .env, never config.json
+        if (method === 'PUT' && /^\/accounts\/\d+\/proxy$/.test(pathname)) {
+            if (pm.getStatus().state !== 'idle') {
+                return sendJson(res, 409, {
+                    error: 'Cannot change a proxy while a bot run is active. Stop the run first.',
+                    code: 'RUN_ACTIVE'
+                })
+            }
+
+            const index = Number(pathname.split('/')[2])
+            const known = new Set(loadAccounts().map(account => account.index))
+            if (!known.has(index)) {
+                return sendJson(res, 404, { error: `ACCOUNT_${index} is not configured.`, code: 'UNKNOWN_ACCOUNT' })
+            }
+
+            const body = await readJsonObject(req)
+            const existing = readAccountProxy(projectRoot, index)
+            try {
+                const proxy = validateProxyInput(body, existing)
+                writeAccountProxy(projectRoot, index, proxy)
+                reloadEnvAccounts(projectRoot)
+                pm.note(
+                    'info',
+                    proxy.url
+                        ? `Proxy for ACCOUNT_${index} set to ${proxy.url}:${proxy.port} (HTTP requests: ${proxy.proxyHttp ? 'on' : 'off'}) via API.`
+                        : `Proxy for ACCOUNT_${index} cleared via API.`
+                )
+                return sendJson(res, 200, {
+                    saved: true,
+                    index,
+                    proxy: readAccountProxy(projectRoot, index),
+                    appliesOnNextRun: true
+                })
+            } catch (err) {
+                const status = err.code === 'BAD_REQUEST' ? 400 : 500
+                return sendJson(res, status, { error: err.message, code: err.code })
+            }
+        }
+
+        // account create; writes ACCOUNT_N_EMAIL into .env
+        if (method === 'POST' && pathname === '/accounts') {
+            const body = await readJsonObject(req)
+            try {
+                const created = addAccountToEnv(projectRoot, body.email)
+                pm.note('info', `Account ${created.email} added as ACCOUNT_${created.index} via API.`)
+                return sendJson(res, 201, { created: true, index: created.index, email: created.email })
+            } catch (err) {
+                if (err.code === 'BAD_REQUEST') return sendJson(res, 400, { error: err.message, code: err.code })
+                if (err.code === 'DUPLICATE') return sendJson(res, 409, { error: err.message, code: err.code })
+                return sendJson(res, 500, { error: err.message })
+            }
+        }
+
+        // account delete; removes every ACCOUNT_N_* line from .env
+        if (method === 'DELETE' && /^\/accounts\/\d+$/.test(pathname)) {
+            if (pm.getStatus().state !== 'idle') {
+                return sendJson(res, 409, {
+                    error: 'Cannot remove an account while a bot run is active. Stop the run first.',
+                    code: 'RUN_ACTIVE'
+                })
+            }
+            const index = Number(pathname.split('/')[2])
+            // Resolve the email before the .env line is gone - it is the only key
+            // the session store has, and a stale cookie row outliving the account
+            // would be handed to whoever gets that index next.
+            const email = loadAccounts().find(account => account.index === index)?.email ?? null
+            try {
+                removeAccountFromEnv(projectRoot, index)
+                const sessions = email ? deleteSessionsForEmail(projectRoot, email) : { found: false, removed: 0 }
+                pm.note('info', `ACCOUNT_${index} removed via API.`)
+                return sendJson(res, 200, { removed: true, index, sessionsRemoved: sessions.removed })
+            } catch (err) {
+                if (err.code === 'BAD_REQUEST') return sendJson(res, 400, { error: err.message, code: err.code })
+                if (err.code === 'UNKNOWN_ACCOUNT') return sendJson(res, 404, { error: err.message, code: err.code })
+                return sendJson(res, 500, { error: err.message })
+            }
+        }
+
         // session list
         if (method === 'GET' && pathname === '/sessions') {
             const loaded = loadConfigSafe(projectRoot)
@@ -570,6 +758,72 @@ const requestHandler = async (req, res) => {
             }
         }
 
+        // task scheduling - list
+        if (method === 'GET' && pathname === '/schedule/tasks') {
+            try {
+                const data = readScheduledTasks(projectRoot)
+                return sendJson(res, 200, data)
+            } catch (err) {
+                return sendJson(res, 500, { error: err.message })
+            }
+        }
+
+        // task scheduling - create
+        if (method === 'POST' && pathname === '/schedule/tasks') {
+            const body = await readJsonObject(req)
+
+            if (!body.accountIndexes || !Array.isArray(body.accountIndexes)) {
+                return sendJson(res, 400, { error: 'accountIndexes array is required' })
+            }
+
+            if (!body.scheduledAt) {
+                return sendJson(res, 400, { error: 'scheduledAt timestamp is required' })
+            }
+
+            const scheduledDate = new Date(body.scheduledAt)
+            if (isNaN(scheduledDate.getTime())) {
+                return sendJson(res, 400, { error: 'Invalid scheduledAt timestamp' })
+            }
+
+            if (scheduledDate <= new Date()) {
+                return sendJson(res, 400, { error: 'scheduledAt must be in the future' })
+            }
+
+            try {
+                const task = addScheduledTask(projectRoot, {
+                    accountIndexes: body.accountIndexes,
+                    scheduledAt: scheduledDate.toISOString(),
+                    headless: Boolean(body.headless),
+                    visualSearch: Boolean(body.visualSearch),
+                    edgeBrowsing: Boolean(body.edgeBrowsing)
+                })
+
+                pm.note('info', `Task ${task.id} scheduled for ${scheduledDate.toISOString()}`)
+                return sendJson(res, 201, { created: true, task })
+            } catch (err) {
+                return sendJson(res, 500, { error: err.message })
+            }
+        }
+
+        // task scheduling - delete
+        if (method === 'DELETE' && pathname.startsWith('/schedule/tasks/')) {
+            const taskId = pathname.slice('/schedule/tasks/'.length)
+            if (!taskId) {
+                return sendJson(res, 400, { error: 'Task ID is required' })
+            }
+
+            try {
+                const result = removeScheduledTask(projectRoot, taskId)
+                pm.note('info', `Task ${taskId} cancelled via API`)
+                return sendJson(res, 200, result)
+            } catch (err) {
+                if (err.code === 'NOT_FOUND') {
+                    return sendJson(res, 404, { error: err.message })
+                }
+                return sendJson(res, 500, { error: err.message })
+            }
+        }
+
         // sse
         if (method === 'GET' && pathname === '/events') {
             return handleEventStream(req, res, url)
@@ -620,6 +874,8 @@ const requestHandler = async (req, res) => {
             const body = await readJsonObject(req)
             const force = readForce(body)
             try {
+                // Surfaces in the UI log console; the bot logs its own abort lines too.
+                pm.note('warn', 'Process Aborted by User')
                 const stopping = pm.stop({ force })
                 stopping.catch(() => {})
                 return sendJson(res, 202, { stopping: true, force })
@@ -799,6 +1055,30 @@ function serveDiagnosticFile(res, pathname) {
     fs.createReadStream(full).pipe(res)
 }
 
+function serveStaticFile(res, pathname) {
+    const safePath = pathname === '/' ? '/index.html' : pathname
+    const filePath = path.join(publicDir, safePath)
+
+    if (!filePath.startsWith(publicDir)) {
+        return sendJson(res, 400, { error: 'Invalid path' })
+    }
+
+    if (!fs.existsSync(filePath)) {
+        return sendJson(res, 404, { error: 'Not found' })
+    }
+
+    const stat = fs.statSync(filePath)
+    if (!stat.isFile()) {
+        return sendJson(res, 404, { error: 'Not found' })
+    }
+
+    const ext = path.extname(filePath)
+    const contentType = MIME_TYPES[ext] || 'application/octet-stream'
+
+    res.writeHead(200, { 'Content-Type': contentType })
+    fs.createReadStream(filePath).pipe(res)
+}
+
 // startup
 const server = http.createServer(requestHandler)
 
@@ -812,7 +1092,9 @@ server.on('error', err => {
 })
 
 server.listen(PORT, HOST, () => {
-    log('INFO', `${pkgName} control API listening on http://${HOST}:${PORT} (headless - no UI)`)
+    log('INFO', `${pkgName} control API with Web UI listening on http://${HOST}:${PORT}`)
+    log('INFO', `Web UI: http://${HOST}:${PORT}`)
+    log('INFO', `API endpoints: http://${HOST}:${PORT}/api`)
     log('INFO', `Launch command: ${command} ${args.join(' ')}`.trim())
     log(
         'INFO',
@@ -841,6 +1123,12 @@ server.listen(PORT, HOST, () => {
         auth: Boolean(TOKEN)
     }
     process.stdout.write(`__API_READY__ ${JSON.stringify(ready)}\n`)
+
+    taskRunner.start()
+    log('INFO', `Scheduler: polling every ${Math.round(taskRunner.tickMs / 1000)}s for due tasks`)
+    // Fire anything already due (server was down when its time passed) without
+    // waiting a full tick.
+    taskRunner.tick().catch(err => log('ERROR', 'Initial scheduler tick failed:', err.message))
 })
 
 let shuttingDown = false
@@ -848,6 +1136,7 @@ async function shutdown(signal, { force = false } = {}) {
     if (shuttingDown) return
     shuttingDown = true
     log('INFO', `${signal} received - shutting down.`)
+    taskRunner.stop()
     server.close()
     try {
         if (pm.getStatus().state !== 'idle') {
diff --git a/scripts/api/sessionStore.js b/scripts/api/sessionStore.js
index 5de1c4b0..2c51d623 100644
--- a/scripts/api/sessionStore.js
+++ b/scripts/api/sessionStore.js
@@ -25,6 +25,44 @@ function closeDatabase(db) {
     } catch {}
 }
 
+// Cookies Microsoft only sets once an account is actually signed in. MUID,
+// MUIDB and SRCHHPGUSR ride along on anonymous traffic too, so their presence
+// proves nothing.
+const AUTH_COOKIES = [
+    { name: 'MSPAuth', domain: 'live.com' },
+    { name: 'MSPProf', domain: 'live.com' },
+    { name: 'WLSSC', domain: 'live.com' },
+    { name: 'RPSSecAuth', domain: 'live.com' },
+    { name: '_U', domain: 'bing.com' }
+]
+
+function normalizeCookieDomain(domain) {
+    return String(domain ?? '')
+        .replace(/^\./, '')
+        .toLowerCase()
+}
+
+function isAuthCookie(cookie) {
+    const domain = normalizeCookieDomain(cookie?.domain)
+    return AUTH_COOKIES.some(
+        entry => entry.name === cookie?.name && (domain === entry.domain || domain.endsWith(`.${entry.domain}`))
+    )
+}
+
+// Playwright stores cookie expiry in seconds, using -1 for session cookies. A
+// session cookie has no recorded expiry; that is not the same as expired.
+function authCookieExpiryMs(cookie) {
+    const expires = Number(cookie?.expires)
+    if (!Number.isFinite(expires) || expires <= 0) return null
+    return expires * 1000
+}
+
+function toIso(ms) {
+    if (ms === null || !Number.isFinite(ms)) return null
+    const date = new Date(ms)
+    return Number.isNaN(date.getTime()) ? null : date.toISOString()
+}
+
 function cookieCount(storageState) {
     if (!storageState) return 0
     try {
@@ -35,9 +73,70 @@ function cookieCount(storageState) {
     }
 }
 
+function parseCookies(storageState) {
+    if (!storageState) return null
+    try {
+        const parsed = JSON.parse(storageState)
+        return Array.isArray(parsed?.cookies) ? parsed.cookies : null
+    } catch {
+        return null
+    }
+}
+
+function inspectAuthCookies(storageState) {
+    const cookies = parseCookies(storageState)
+    if (cookies === null) {
+        // parse failure: storage_state exists but is corrupt
+        return storageState
+            ? { liveCount: 0, expiredCount: 0, totalAuth: 0, nextExpiryMs: null, parseError: true }
+            : { liveCount: 0, expiredCount: 0, totalAuth: 0, nextExpiryMs: null, parseError: false }
+    }
+
+    const now = Date.now()
+    let liveCount = 0
+    let expiredCount = 0
+    let nextExpiryMs = null
+
+    for (const cookie of cookies) {
+        if (!isAuthCookie(cookie)) continue
+        const expiryMs = authCookieExpiryMs(cookie)
+        // null expiry means session cookie — still live, no recorded expiry
+        if (expiryMs === null) {
+            liveCount++
+            continue
+        }
+        if (expiryMs > now) {
+            liveCount++
+            if (nextExpiryMs === null || expiryMs < nextExpiryMs) nextExpiryMs = expiryMs
+        } else {
+            expiredCount++
+        }
+    }
+
+    return {
+        liveCount,
+        expiredCount,
+        totalAuth: liveCount + expiredCount,
+        nextExpiryMs,
+        parseError: false
+    }
+}
+
+function sessionAuthStatus(storageState) {
+    if (!storageState) return 'not-logged-in'
+    const info = inspectAuthCookies(storageState)
+    if (info.parseError) return 'expired'
+    if (info.liveCount > 0) return 'logged-in'
+    // Has a row but no live Microsoft auth cookies — stale/expired even if
+    // anonymous cookies like MUID still linger.
+    if (cookieCount(storageState) > 0) return 'expired'
+    return 'not-logged-in'
+}
+
 function toSession(row) {
     const updatedAt = Number(row.updated_at)
     const updatedDate = new Date(updatedAt)
+    const auth = inspectAuthCookies(row.storage_state)
     return {
         email: row.email,
         platform: row.platform,
@@ -45,7 +144,12 @@ function toSession(row) {
             Number.isFinite(updatedAt) && !Number.isNaN(updatedDate.getTime()) ? updatedDate.toISOString() : null,
         hasStorageState: Boolean(row.storage_state),
         hasFingerprint: Boolean(row.fingerprint),
-        cookieCount: cookieCount(row.storage_state)
+        cookieCount: cookieCount(row.storage_state),
+        authStatus: sessionAuthStatus(row.storage_state),
+        liveAuthCookieCount: auth.liveCount,
+        expiredAuthCookieCount: auth.expiredCount,
+        nextAuthExpiry: toIso(auth.nextExpiryMs),
+        parseError: auth.parseError
     }
 }
 
@@ -75,6 +179,40 @@ export function listStoredSessions(projectRoot, sessionPath) {
     }
 }
 
+const LOGIN_RANK = { 'logged-in': 2, expired: 1, 'not-logged-in': 0 }
+
+export function getSessionLoginStatusMap(projectRoot, sessionPath) {
+    const listed = listStoredSessions(projectRoot, sessionPath)
+    if (!listed.databaseExists) return null
+
+    const map = new Map()
+    for (const session of listed.sessions) {
+        const key = session.email.toLowerCase()
+        const current = map.get(key)
+        if (!current || LOGIN_RANK[session.authStatus] > LOGIN_RANK[current.status]) {
+            map.set(key, {
+                status: session.authStatus,
+                updatedAt: session.updatedAt,
+                liveAuthCookieCount: session.liveAuthCookieCount,
+                nextAuthExpiry: session.nextAuthExpiry
+            })
+        } else if (LOGIN_RANK[session.authStatus] === LOGIN_RANK[current.status]) {
+            // Tie-break: keep the freshest row.
+            const a = session.updatedAt ? Date.parse(session.updatedAt) : 0
+            const b = current.updatedAt ? Date.parse(current.updatedAt) : 0
+            if (a > b) {
+                map.set(key, {
+                    status: session.authStatus,
+                    updatedAt: session.updatedAt,
+                    liveAuthCookieCount: session.liveAuthCookieCount,
+                    nextAuthExpiry: session.nextAuthExpiry
+                })
+            }
+        }
+    }
+    return map
+}
+
 export function deleteStoredSessions(projectRoot, sessionPath, email) {
     const { dbPath, exists } = resolveSessionDb(projectRoot, sessionPath)
     if (!exists) return { found: false, removed: 0, email, platforms: [] }
diff --git a/scripts/api/taskRunner.js b/scripts/api/taskRunner.js
new file mode 100644
index 00000000..b47f2715
--- /dev/null
+++ b/scripts/api/taskRunner.js
@@ -0,0 +1,137 @@
+import { partitionDueTasks, updateTaskStatus } from './taskScheduler.js'
+
+const DEFAULT_TICK_MS = 30_000
+
+/**
+ * Polls the persisted schedule and starts runs whose time has come.
+ *
+ * Kept as a plain interval rather than node-cron/BullMQ: the API is dependency-free
+ * by design, tasks are one-shot wall-clock times (not cron expressions), and the
+ * schedule already survives restarts on disk.
+ */
+export class TaskRunner {
+    constructor({ projectRoot, pm, buildEnvForTask, tickMs = DEFAULT_TICK_MS }) {
+        this.projectRoot = projectRoot
+        this.pm = pm
+        this.buildEnvForTask = buildEnvForTask
+        this.tickMs = tickMs
+
+        this.timer = null
+        this.ticking = false
+        // Task the runner handed to the process manager, so its outcome can be recorded.
+        this.activeTaskId = null
+
+        this._onExit = exit => this._finishActive(exit)
+    }
+
+    start() {
+        if (this.timer) return
+        this.pm.on('exit', this._onExit)
+        this.timer = setInterval(() => {
+            this.tick().catch(error => {
+                this.pm.note('error', `Scheduler tick failed: ${error.message}`)
+            })
+        }, this.tickMs)
+        if (typeof this.timer.unref === 'function') this.timer.unref()
+    }
+
+    stop() {
+        if (this.timer) clearInterval(this.timer)
+        this.timer = null
+        this.pm.off('exit', this._onExit)
+    }
+
+    async tick() {
+        if (this.ticking) return
+        this.ticking = true
+        try {
+            const { due, missed } = partitionDueTasks(this.projectRoot)
+
+            for (const task of missed) {
+                this._patch(task.id, {
+                    status: 'missed',
+                    finishedAt: new Date().toISOString(),
+                    error: 'Scheduled time passed without an available run slot.'
+                })
+                this.pm.note('warn', `Scheduled task ${task.id} missed its window and will not run.`)
+            }
+
+            if (!due.length) return
+
+            // One run at a time: the bot owns the browser profile, so a second
+            // concurrent run would fight over it. Remaining tasks wait for the
+            // next tick and are marked missed once the grace window closes.
+            if (this.pm.state !== 'idle' || this.activeTaskId) return
+
+            const task = due[0]
+            this._startTask(task)
+        } finally {
+            this.ticking = false
+        }
+    }
+
+    _startTask(task) {
+        let env
+        try {
+            env = this.buildEnvForTask(task)
+        } catch (error) {
+            this._patch(task.id, {
+                status: 'failed',
+                finishedAt: new Date().toISOString(),
+                error: error.message
+            })
+            this.pm.note('error', `Scheduled task ${task.id} could not start: ${error.message}`)
+            return
+        }
+
+        // Claim the task before spawning so a tick that overlaps a slow spawn
+        // cannot pick it up again.
+        this._patch(task.id, { status: 'running', startedAt: new Date().toISOString() })
+        this.activeTaskId = task.id
+
+        try {
+            this.pm.start({ env })
+            this.pm.note(
+                'info',
+                `Scheduled task ${task.id} started | accounts=${task.accountIndexes.join(',')} | headless=${Boolean(task.headless)}`
+            )
+        } catch (error) {
+            this.activeTaskId = null
+            const status = error.code === 'ALREADY_RUNNING' ? 'pending' : 'failed'
+            this._patch(task.id, {
+                status,
+                startedAt: null,
+                finishedAt: status === 'failed' ? new Date().toISOString() : null,
+                error: status === 'failed' ? error.message : null
+            })
+            if (status === 'failed') {
+                this.pm.note('error', `Scheduled task ${task.id} failed to start: ${error.message}`)
+            }
+        }
+    }
+
+    _finishActive(exit) {
+        const taskId = this.activeTaskId
+        if (!taskId) return
+        this.activeTaskId = null
+
+        const ok = exit?.code === 0
+        this._patch(taskId, {
+            status: ok ? 'done' : 'failed',
+            finishedAt: new Date().toISOString(),
+            error: ok ? null : `Run exited with code ${exit?.code ?? 'null'}${exit?.signal ? ` (${exit.signal})` : ''}`
+        })
+        this.pm.note(ok ? 'info' : 'error', `Scheduled task ${taskId} finished (${ok ? 'success' : 'failure'}).`)
+    }
+
+    _patch(taskId, patch) {
+        try {
+            updateTaskStatus(this.projectRoot, taskId, patch)
+        } catch (error) {
+            // A task deleted mid-flight is normal; anything else is worth surfacing.
+            if (error.code !== 'NOT_FOUND') {
+                this.pm.note('error', `Could not update task ${taskId}: ${error.message}`)
+            }
+        }
+    }
+}
diff --git a/scripts/api/taskScheduler.js b/scripts/api/taskScheduler.js
new file mode 100644
index 00000000..9c984f64
--- /dev/null
+++ b/scripts/api/taskScheduler.js
@@ -0,0 +1,152 @@
+import { readFileSync, writeFileSync, existsSync, renameSync } from 'node:fs'
+import { join } from 'node:path'
+
+const SCHEDULE_FILE = 'scheduled_tasks.json'
+
+// How long a finished task stays visible in the UI before it is pruned.
+const RETENTION_MS = 24 * 60 * 60 * 1000
+
+// A task that could not start within this window after its time (server was off,
+// or another run was in progress the whole time) is marked missed instead of
+// firing hours late.
+const MISS_GRACE_MS = 60 * 60 * 1000
+
+const TERMINAL = new Set(['done', 'failed', 'missed', 'cancelled'])
+
+function filePathFor(projectRoot) {
+    return join(projectRoot, SCHEDULE_FILE)
+}
+
+function normalizeTask(task) {
+    return {
+        status: 'pending',
+        startedAt: null,
+        finishedAt: null,
+        error: null,
+        ...task
+    }
+}
+
+function isExpired(task, now) {
+    if (!TERMINAL.has(task.status)) return false
+    const endedAt = Date.parse(task.finishedAt ?? task.scheduledAt)
+    if (Number.isNaN(endedAt)) return false
+    return now - endedAt > RETENTION_MS
+}
+
+/**
+ * Reads the persisted tasks. Past-due tasks are kept - the runner needs to see
+ * them to fire or expire them - and only long-finished ones are pruned.
+ */
+export function readScheduledTasks(projectRoot) {
+    const filePath = filePathFor(projectRoot)
+
+    if (!existsSync(filePath)) {
+        return { tasks: [] }
+    }
+
+    let data
+    try {
+        data = JSON.parse(readFileSync(filePath, 'utf8'))
+    } catch {
+        return { tasks: [] }
+    }
+
+    const stored = Array.isArray(data?.tasks) ? data.tasks : []
+    const now = Date.now()
+    const tasks = stored.map(normalizeTask).filter(task => !isExpired(task, now))
+
+    if (tasks.length !== stored.length) {
+        writeScheduledTasks(projectRoot, tasks)
+    }
+
+    tasks.sort((a, b) => Date.parse(a.scheduledAt) - Date.parse(b.scheduledAt))
+    return { tasks }
+}
+
+export function writeScheduledTasks(projectRoot, tasks) {
+    const filePath = filePathFor(projectRoot)
+    const data = { tasks, updatedAt: new Date().toISOString() }
+
+    try {
+        // Write-then-rename so a crash mid-write cannot truncate the schedule.
+        const tmpPath = `${filePath}.tmp`
+        writeFileSync(tmpPath, JSON.stringify(data, null, 2), 'utf8')
+        renameSync(tmpPath, filePath)
+        return data
+    } catch (error) {
+        const err = new Error(`Failed to write scheduled tasks: ${error.message}`)
+        err.code = 'WRITE_FAILED'
+        throw err
+    }
+}
+
+export function addScheduledTask(projectRoot, task) {
+    const { tasks } = readScheduledTasks(projectRoot)
+
+    const newTask = normalizeTask({
+        id: `task_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+        ...task,
+        createdAt: new Date().toISOString()
+    })
+
+    tasks.push(newTask)
+    writeScheduledTasks(projectRoot, tasks)
+
+    return newTask
+}
+
+export function removeScheduledTask(projectRoot, taskId) {
+    const { tasks } = readScheduledTasks(projectRoot)
+    const filtered = tasks.filter(task => task.id !== taskId)
+
+    if (filtered.length === tasks.length) {
+        const err = new Error(`Task ${taskId} not found`)
+        err.code = 'NOT_FOUND'
+        throw err
+    }
+
+    writeScheduledTasks(projectRoot, filtered)
+    return { deleted: true, taskId }
+}
+
+/**
+ * Returns tasks whose time has arrived and that are still waiting to run,
+ * oldest first, plus the ones that sat unstarted past the grace window.
+ */
+export function partitionDueTasks(projectRoot, now = Date.now()) {
+    const { tasks } = readScheduledTasks(projectRoot)
+    const due = []
+    const missed = []
+
+    for (const task of tasks) {
+        if (task.status !== 'pending') continue
+        const at = Date.parse(task.scheduledAt)
+        if (Number.isNaN(at) || at > now) continue
+        if (now - at > MISS_GRACE_MS) missed.push(task)
+        else due.push(task)
+    }
+
+    return { due, missed }
+}
+
+/**
+ * Flips a task to a new status in one read-modify-write so the runner never
+ * starts the same task twice.
+ */
+export function updateTaskStatus(projectRoot, taskId, patch) {
+    const { tasks } = readScheduledTasks(projectRoot)
+    const index = tasks.findIndex(task => task.id === taskId)
+
+    if (index === -1) {
+        const err = new Error(`Task ${taskId} not found`)
+        err.code = 'NOT_FOUND'
+        throw err
+    }
+
+    const updated = { ...tasks[index], ...patch }
+    tasks[index] = updated
+    writeScheduledTasks(projectRoot, tasks)
+
+    return updated
+}
diff --git a/src/browser/Browser.ts b/src/browser/Browser.ts
index 37850359..a1a106a8 100644
--- a/src/browser/Browser.ts
+++ b/src/browser/Browser.ts
@@ -6,6 +6,7 @@ import type { MicrosoftRewardsBot } from '../index'
 import { loadSession, saveFingerprint } from '../util/SessionStore'
 import { fingerprintMatchesLocale } from '../util/Locale'
 import { formatBrowserProxyServer } from '../util/Proxy'
+import { registerBrowser, unregisterBrowser } from '../util/Abort'
 import { UserAgentManager } from './UserAgent'
 
 import type { Account } from '../interface/Account'
@@ -93,6 +94,10 @@ class Browser {
                 ...(proxyConfig && { proxy: proxyConfig }),
                 args: [...Browser.BROWSER_ARGS, ...sandboxArgs, ...certArgs]
             })
+
+            // Tracked so an abort can force-close it even mid-activity.
+            registerBrowser(browser)
+            browser.on('disconnected', () => unregisterBrowser(browser))
         } catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error)
             this.bot.logger.error(this.bot.isMobile, 'BROWSER', `Browser launch failed: ${errorMessage}`)
diff --git a/src/functions/activities/experimental/EdgeBrowsing.ts b/src/functions/activities/experimental/EdgeBrowsing.ts
index 2a687d50..407094d7 100644
--- a/src/functions/activities/experimental/EdgeBrowsing.ts
+++ b/src/functions/activities/experimental/EdgeBrowsing.ts
@@ -6,6 +6,7 @@ import type { AppDashboardData, Promotion } from '../../../interface/AppDashBoar
 import type { DashboardData } from '../../../interface/DashboardData'
 import { BaseActivity } from '../BaseActivity'
 import { EdgeBrowsingProgress, type EdgeBrowsingProgressSnapshot } from './EdgeBrowsingProgress'
+import { EdgeLiveBrowsing } from './EdgeLiveBrowsing'
 
 const LOG_TAG = 'EDGE-BROWSING'
 const PROMOTION_NAME = 'edge_browsing_streak_flight'
@@ -124,6 +125,15 @@ export class EdgeBrowsing extends BaseActivity {
                     ` | estimatedDurationMinutes=${progress.estimatedDurationMinutes}`
             )
 
+            // Real browsing session (scrolling, reading, clicking) alongside the report loop.
+            const liveBrowsing = new EdgeLiveBrowsing(this.bot).run(signal).catch(error => {
+                this.bot.logger.warn(
+                    this.bot.isMobile,
+                    LOG_TAG,
+                    `Live browsing session failed | message=${error instanceof Error ? error.message : String(error)}`
+                )
+            })
+
             for (let reportNumber = 1; reportNumber <= reportCount; reportNumber++) {
                 const beforeReport = progress.snapshot(reportNumber - 1)
 
@@ -202,6 +212,8 @@ export class EdgeBrowsing extends BaseActivity {
                 serverComplete = await this.refreshServerCompletion(accessToken, reportsProcessed, reportCount)
             }
 
+            await liveBrowsing
+
             const finished = progress.snapshot(reportsProcessed)
             const summary =
                 `Finished background Edge browsing activity | reports=${reportsProcessed}` +
diff --git a/src/functions/activities/experimental/EdgeLiveBrowsing.ts b/src/functions/activities/experimental/EdgeLiveBrowsing.ts
new file mode 100644
index 00000000..6ba833ce
--- /dev/null
+++ b/src/functions/activities/experimental/EdgeLiveBrowsing.ts
@@ -0,0 +1,223 @@
+import type { Page } from 'patchright'
+
+import type { MicrosoftRewardsBot } from '../../../index'
+
+const LOG_TAG = 'EDGE-BROWSING'
+const SESSION_MINUTES = 30
+const READ_BUDGET_MIN_MS = 45_000
+const READ_BUDGET_MAX_MS = 120_000
+
+// Hosts a browsing session may follow; anything else is treated as unsafe and skipped.
+const SAFE_HOST_SUFFIXES = ['bing.com', 'microsoft.com', 'msn.com', 'microsoftedge.com']
+
+const DEFAULT_FEED = 'https://www.msn.com/en-us/news'
+
+const FEED_URLS = [
+    DEFAULT_FEED,
+    'https://www.msn.com/en-us/money',
+    'https://www.msn.com/en-us/lifestyle',
+    'https://www.msn.com/en-us/entertainment',
+    'https://www.bing.com/news/search?q=technology',
+    'https://www.bing.com/news/search?q=science',
+    'https://www.bing.com/news/search?q=sports',
+    'https://www.bing.com/news/search?q=health'
+]
+
+/**
+ * Keeps a real browser tab open for TARGET 30 minutes, scrolling and clicking like a reader.
+ * Runs in a tab of an already-authenticated context so fingerprints and cookies stay consistent.
+ */
+export class EdgeLiveBrowsing {
+    constructor(private readonly bot: MicrosoftRewardsBot) {}
+
+    public async run(signal?: AbortSignal): Promise<void> {
+        const startedAt = Date.now()
+        const deadline = startedAt + SESSION_MINUTES * 60_000
+
+        const page = await this.openPage(signal)
+        if (!page) {
+            this.bot.logger.info(
+                this.bot.isMobile,
+                LOG_TAG,
+                'Live browsing skipped: no open browser context in this run'
+            )
+            return
+        }
+
+        let pagesRead = 0
+        let linksClicked = 0
+
+        this.bot.logger.info(
+            this.bot.isMobile,
+            LOG_TAG,
+            `Started live Edge browsing session | minutes=${SESSION_MINUTES} | startUrl=${page.url()}`
+        )
+
+        try {
+            while (Date.now() < deadline && !signal?.aborted) {
+                await this.readPage(page, deadline, signal)
+                if (signal?.aborted || Date.now() >= deadline) break
+                pagesRead++
+
+                // Readers mostly finish a page and move on; sometimes they follow a link.
+                if (Math.random() < 0.35 && (await this.clickSafeLink(page))) {
+                    linksClicked++
+                } else {
+                    await this.gotoFeed(page)
+                }
+
+                await this.wait(this.bot.utils.randomDelay(2000, 6000), signal)
+            }
+        } catch (error) {
+            if (!signal?.aborted) {
+                this.bot.logger.warn(
+                    this.bot.isMobile,
+                    LOG_TAG,
+                    `Live browsing interrupted | message=${error instanceof Error ? error.message : String(error)}`
+                )
+            }
+        } finally {
+            const minutes = Math.round((Date.now() - startedAt) / 60_000)
+            this.bot.logger.info(
+                this.bot.isMobile,
+                LOG_TAG,
+                `Finished live Edge browsing session | minutes=${minutes} | pagesRead=${pagesRead} | linkClicks=${linksClicked}`,
+                'green'
+            )
+            await page.close().catch(() => undefined)
+        }
+    }
+
+    private async openPage(signal?: AbortSignal): Promise<Page | null> {
+        // The mobile context lives for the whole run; the desktop one may close early.
+        const candidates = [this.bot.mainMobilePage, this.bot.mainDesktopPage]
+
+        for (const source of candidates) {
+            if (signal?.aborted) return null
+            try {
+                if (!source || source.isClosed()) continue
+                const context = source.context()
+                if (context.isClosed()) continue
+
+                const page = await context.newPage()
+                await page.goto(this.pickFeed(), { waitUntil: 'domcontentloaded', timeout: 30_000 })
+                return page
+            } catch {
+                continue
+            }
+        }
+
+        return null
+    }
+
+    private async readPage(page: Page, deadline: number, signal?: AbortSignal): Promise<void> {
+        const budget = Math.min(
+            this.bot.utils.randomDelay(READ_BUDGET_MIN_MS, READ_BUDGET_MAX_MS),
+            Math.max(5_000, deadline - Date.now())
+        )
+        const until = Date.now() + budget
+
+        while (Date.now() < until && !signal?.aborted) {
+            let atBottom: boolean
+            try {
+                atBottom = await page.evaluate(() => {
+                    const doc = document.documentElement
+                    return window.scrollY + window.innerHeight >= doc.scrollHeight - 40
+                })
+            } catch {
+                return
+            }
+            if (atBottom) break
+
+            await page.mouse.wheel(0, this.bot.utils.randomDelay(250, 700)).catch(() => undefined)
+
+            // Mostly short reading pauses, occasionally a long one like a human re-reading a paragraph.
+            const longPause = Math.random() < 0.12
+            const delay = longPause ? this.bot.utils.randomDelay(3000, 6000) : this.bot.utils.randomDelay(700, 2200)
+            if (!(await this.wait(delay, signal))) return
+        }
+
+        // Dwell at the end of the article before moving on.
+        await this.wait(this.bot.utils.randomDelay(2000, 6000), signal)
+    }
+
+    private async clickSafeLink(page: Page): Promise<boolean> {
+        let hrefs: string[]
+        try {
+            hrefs = await page.$$eval('a[href]', anchors =>
+                (anchors as HTMLAnchorElement[]).map(a => a.href).filter(h => /^https?:\/\//i.test(h))
+            )
+        } catch {
+            return false
+        }
+
+        let currentHost = ''
+        try {
+            currentHost = new URL(page.url()).hostname
+        } catch {
+            return false
+        }
+
+        const safe = hrefs.filter(href => {
+            try {
+                const host = new URL(href).hostname
+                return (
+                    host === currentHost ||
+                    SAFE_HOST_SUFFIXES.some(suffix => host === suffix || host.endsWith(`.${suffix}`))
+                )
+            } catch {
+                return false
+            }
+        })
+        if (!safe.length) return false
+
+        const target = safe[Math.floor(Math.random() * safe.length)]
+        if (!target) return false
+
+        try {
+            await page.goto(target, { waitUntil: 'domcontentloaded', timeout: 20_000 })
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                LOG_TAG,
+                `Live browsing followed a link | host=${new URL(target).hostname}`
+            )
+            return true
+        } catch {
+            return false
+        }
+    }
+
+    private async gotoFeed(page: Page): Promise<void> {
+        try {
+            await page.goto(this.pickFeed(), { waitUntil: 'domcontentloaded', timeout: 25_000 })
+        } catch {
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                LOG_TAG,
+                'Live browsing page load timed out; continuing on the current page'
+            )
+        }
+    }
+
+    private pickFeed(): string {
+        return FEED_URLS[Math.floor(Math.random() * FEED_URLS.length)] ?? DEFAULT_FEED
+    }
+
+    private wait(delayMs: number, signal?: AbortSignal): Promise<boolean> {
+        if (signal?.aborted) return Promise.resolve(false)
+        if (!signal) return this.bot.utils.wait(delayMs).then(() => true)
+
+        return new Promise(resolve => {
+            const onAbort = () => {
+                clearTimeout(timeout)
+                resolve(false)
+            }
+            const timeout = setTimeout(() => {
+                signal.removeEventListener('abort', onAbort)
+                resolve(true)
+            }, delayMs)
+
+            signal.addEventListener('abort', onAbort, { once: true })
+        })
+    }
+}
diff --git a/src/index.ts b/src/index.ts
index ae19c491..18429261 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -16,6 +16,7 @@ import Utils, { isBrowserClosedError } from './util/Utils'
 import { loadAccounts, loadConfig } from './util/Load'
 import { closeSessionStore, loadResolvedRegion, saveResolvedRegion } from './util/SessionStore'
 import { checkNodeVersion } from './util/Validator'
+import { abortRun, abortSignal, isAborted, isAbortError } from './util/Abort'
 import { normalizeCountry, resolveAccountLocale } from './util/Locale'
 import type { AccountLocale } from './util/Locale'
 
@@ -410,6 +411,12 @@ export class MicrosoftRewardsBot {
         const accountStats: AccountStats[] = []
 
         for (const [accountIndex, account] of accounts.entries()) {
+            // Stop between accounts so an abort does not start a fresh login.
+            if (isAborted()) {
+                this.logger.warn('main', 'ABORT', 'Process aborted by user - skipping remaining accounts')
+                break
+            }
+
             if (accountIndex > 0) {
                 await this.waitBeforeNextAccount(account.email)
             }
@@ -439,6 +446,10 @@ export class MicrosoftRewardsBot {
                 })
 
                 const result: AccountRunResult | undefined = await this.Main(account).catch(error => {
+                    if (isAbortError(error) || isAborted()) {
+                        void this.logger.warn('main', 'ABORT', `Process aborted by user during ${accountEmail}`)
+                        return undefined
+                    }
                     void this.logger.error(
                         true,
                         'FLOW',
@@ -555,7 +566,18 @@ export class MicrosoftRewardsBot {
                 nextEmail ? ` (${nextEmail})` : ''
             }`
         )
-        await this.utils.wait(delayMs)
+        await new Promise<void>(resolve => {
+            const timer = setTimeout(() => {
+                abortSignal.removeEventListener('abort', onAbort)
+                resolve()
+            }, delayMs)
+            // Otherwise a Stop during a multi-minute delay would look frozen.
+            const onAbort = (): void => {
+                clearTimeout(timer)
+                resolve()
+            }
+            abortSignal.addEventListener('abort', onAbort, { once: true })
+        })
     }
 
     async createDesktopSession(account: Account): Promise<BrowserSession> {
@@ -596,6 +618,9 @@ export class MicrosoftRewardsBot {
         let mobileSession: BrowserSession | null = null
         let desktopSession: BrowserSession | null = null
         const edgeBrowsingController = new AbortController()
+        // A user abort must also cancel the 30-minute background task.
+        const onRunAbort = (): void => edgeBrowsingController.abort()
+        abortSignal.addEventListener('abort', onRunAbort, { once: true })
         let edgeBrowsingTask: Promise<void> | null = null
         let edgeBrowsingFinished = false
 
@@ -933,6 +958,8 @@ export class MicrosoftRewardsBot {
                 }
             })
         } finally {
+            abortSignal.removeEventListener('abort', onRunAbort)
+
             if (edgeBrowsingTask) {
                 edgeBrowsingController.abort()
                 await edgeBrowsingTask
@@ -975,16 +1002,35 @@ async function main(): Promise<void> {
     process.on('beforeExit', () => {
         void flushAllWebhooks()
     })
-    process.on('SIGINT', async () => {
-        rewardsBot.logger.warn('main', 'PROCESS', 'SIGINT received, flushing and exiting...')
-        await flushAllWebhooks()
-        process.exit(130)
-    })
-    process.on('SIGTERM', async () => {
-        rewardsBot.logger.warn('main', 'PROCESS', 'SIGTERM received, flushing and exiting...')
+    // Stop requests arrive as signals from the control API. Abort first so every
+    // tracked Chromium is closed, then flush and exit - otherwise the browsers
+    // only die because the OS reaps the process tree.
+    let aborting = false
+    const onStopSignal = async (signal: 'SIGINT' | 'SIGTERM', exitCode: number): Promise<void> => {
+        if (aborting) return
+        aborting = true
+
+        rewardsBot.logger.warn('main', 'ABORT', `Process aborted by user (${signal}) - closing browsers...`)
+        const closed = await abortRun()
+        rewardsBot.logger.warn('main', 'ABORT', `Process aborted by user | browsersClosed=${closed}`)
+
         await flushAllWebhooks()
-        process.exit(143)
-    })
+        process.exit(exitCode)
+    }
+    process.on('SIGINT', () => void onStopSignal('SIGINT', 130))
+    process.on('SIGTERM', () => void onStopSignal('SIGTERM', 143))
+
+    // The control API writes this on stdin because Windows cannot deliver a real
+    // SIGTERM to a child; without it a stop would hard-kill and orphan Chromium.
+    if (!process.stdin.isTTY) {
+        process.stdin.setEncoding('utf8')
+        process.stdin.on('data', chunk => {
+            if (chunk.includes('__ABORT__')) void onStopSignal('SIGTERM', 143)
+        })
+        process.stdin.on('error', () => undefined)
+        // Do not hold the event loop open just for this listener.
+        process.stdin.unref()
+    }
     process.on('uncaughtException', async error => {
         if (isBrowserClosedError(error)) {
             rewardsBot.logger.debug(
diff --git a/src/util/Abort.ts b/src/util/Abort.ts
new file mode 100644
index 00000000..66b1a034
--- /dev/null
+++ b/src/util/Abort.ts
@@ -0,0 +1,65 @@
+/**
+ * Run-wide cancellation.
+ *
+ * The API stops a run by signalling the process (SIGTERM, then SIGKILL on a
+ * timeout). Chromium is a child of this process, so the OS-level kill already
+ * prevents zombies. What the signal alone does NOT do is give the run a chance
+ * to close browsers cleanly, so this registry exists to:
+ *   - expose an AbortSignal that long loops can poll to bail out early, and
+ *   - close every live browser (saving nothing, just releasing the processes)
+ *     before we exit, so no Chromium outlives us if it ever escaped the tree.
+ */
+
+type Closable = { close: () => Promise<unknown> }
+
+const controller = new AbortController()
+const browsers = new Set<Closable>()
+
+/** Signal that flips when the user aborts the run. */
+export const abortSignal: AbortSignal = controller.signal
+
+export function isAborted(): boolean {
+    return controller.signal.aborted
+}
+
+/** Throws if the run was aborted. Call between steps to unwind promptly. */
+export function throwIfAborted(): void {
+    if (controller.signal.aborted) {
+        throw new AbortError()
+    }
+}
+
+export class AbortError extends Error {
+    constructor() {
+        super('Process aborted by user')
+        this.name = 'AbortError'
+    }
+}
+
+export function isAbortError(error: unknown): boolean {
+    return error instanceof AbortError || (error instanceof Error && error.name === 'AbortError')
+}
+
+/** Track a launched browser so abort can force it closed. */
+export function registerBrowser(browser: Closable): void {
+    browsers.add(browser)
+}
+
+export function unregisterBrowser(browser: Closable): void {
+    browsers.delete(browser)
+}
+
+/**
+ * Flip the signal and force every tracked browser closed. Safe to call twice.
+ * Returns how many browsers it closed so the caller can log it.
+ */
+export async function abortRun(): Promise<number> {
+    controller.abort()
+
+    const pending = [...browsers]
+    browsers.clear()
+
+    // close() rejects if the browser already died; that is the outcome we want anyway.
+    await Promise.allSettled(pending.map(browser => browser.close()))
+    return pending.length
+}
diff --git a/src/util/ConfigEnvOverrides.ts b/src/util/ConfigEnvOverrides.ts
index 10dc65e3..ec999d64 100644
--- a/src/util/ConfigEnvOverrides.ts
+++ b/src/util/ConfigEnvOverrides.ts
@@ -6,10 +6,12 @@ export interface EnvOverrideEntry {
     env: string
     path: string // dotted path into config.json
     type: OverrideType
+    secret?: boolean // never print the value; applied overrides are logged
 }
 
 export const ENV_OVERRIDES: EnvOverrideEntry[] = [
     // General
+    { env: 'CONFIG_HEADLESS', path: 'headless', type: 'bool' },
     { env: 'CONFIG_CLUSTERS', path: 'clusters', type: 'number' },
     { env: 'CONFIG_DEBUG_LOGS', path: 'debugLogs', type: 'bool' },
     { env: 'CONFIG_ERROR_DIAGNOSTICS', path: 'errorDiagnostics', type: 'bool' },
@@ -72,18 +74,18 @@ export const ENV_OVERRIDES: EnvOverrideEntry[] = [
 
     // Discord webhook
     { env: 'CONFIG_DISCORD_ENABLED', path: 'webhook.discord.enabled', type: 'bool' },
-    { env: 'CONFIG_DISCORD_URL', path: 'webhook.discord.url', type: 'string' },
+    { env: 'CONFIG_DISCORD_URL', path: 'webhook.discord.url', type: 'string', secret: true },
 
     // Telegram webhook
     { env: 'CONFIG_TELEGRAM_ENABLED', path: 'webhook.telegram.enabled', type: 'bool' },
-    { env: 'CONFIG_TELEGRAM_BOTTOKEN', path: 'webhook.telegram.botToken', type: 'string' },
-    { env: 'CONFIG_TELEGRAM_CHATID', path: 'webhook.telegram.chatId', type: 'string' },
+    { env: 'CONFIG_TELEGRAM_BOTTOKEN', path: 'webhook.telegram.botToken', type: 'string', secret: true },
+    { env: 'CONFIG_TELEGRAM_CHATID', path: 'webhook.telegram.chatId', type: 'string', secret: true },
 
     // ntfy webhook (tags are comma-separated e.g. "bot,notify")
     { env: 'CONFIG_NTFY_ENABLED', path: 'webhook.ntfy.enabled', type: 'bool' },
-    { env: 'CONFIG_NTFY_URL', path: 'webhook.ntfy.url', type: 'string' },
-    { env: 'CONFIG_NTFY_TOPIC', path: 'webhook.ntfy.topic', type: 'string' },
-    { env: 'CONFIG_NTFY_TOKEN', path: 'webhook.ntfy.token', type: 'string' },
+    { env: 'CONFIG_NTFY_URL', path: 'webhook.ntfy.url', type: 'string', secret: true },
+    { env: 'CONFIG_NTFY_TOPIC', path: 'webhook.ntfy.topic', type: 'string', secret: true },
+    { env: 'CONFIG_NTFY_TOKEN', path: 'webhook.ntfy.token', type: 'string', secret: true },
     { env: 'CONFIG_NTFY_TITLE', path: 'webhook.ntfy.title', type: 'string' },
     { env: 'CONFIG_NTFY_PRIORITY', path: 'webhook.ntfy.priority', type: 'number' },
     { env: 'CONFIG_NTFY_TAGS', path: 'webhook.ntfy.tags', type: 'array' },
@@ -95,7 +97,13 @@ export const ENV_OVERRIDES: EnvOverrideEntry[] = [
     { env: 'CONFIG_WEBHOOK_LOG_FILTER_KEYWORDS', path: 'webhook.webhookLogFilter.keywords', type: 'array' }
 ]
 
-const FORCED_OVERRIDES: { path: string; value: unknown }[] = [{ path: 'headless', value: true }]
+// Docker images set FORCE_HEADLESS=1 because containers have no display, so
+// headless is pinned there and CONFIG_HEADLESS cannot turn it off.
+function forcedOverrides(env: NodeJS.ProcessEnv): { path: string; value: unknown }[] {
+    const raw = env.FORCE_HEADLESS?.trim().toLowerCase()
+    const forced = raw !== undefined && ['1', 'true', 'yes', 'on'].includes(raw)
+    return forced ? [{ path: 'headless', value: true }] : []
+}
 
 function setDeep(obj: Record<string, unknown>, dottedPath: string, value: unknown): void {
     const parts = dottedPath.split('.')
@@ -111,15 +119,21 @@ function setDeep(obj: Record<string, unknown>, dottedPath: string, value: unknow
     cur[parts[parts.length - 1] as string] = value
 }
 
+// Shells, compose files and CI runners all spell booleans differently, so accept
+// the same set Load.ts accepts for its own env flags instead of only true/false.
+const TRUE_WORDS = new Set(['1', 'true', 'yes', 'on'])
+const FALSE_WORDS = new Set(['0', 'false', 'no', 'off'])
+
 function coerceScalar(raw: string, type: 'bool' | 'number' | 'string', env: string): unknown {
     switch (type) {
-        case 'bool':
-            if (raw !== 'true' && raw !== 'false') {
-                throw new Error(`${env} expects true or false, got '${raw}'.`)
-            }
-            return raw === 'true'
+        case 'bool': {
+            const word = raw.trim().toLowerCase()
+            if (TRUE_WORDS.has(word)) return true
+            if (FALSE_WORDS.has(word)) return false
+            throw new Error(`${env} expects a boolean (true/false, 1/0, yes/no, on/off), got '${raw}'.`)
+        }
         case 'number': {
-            const n = Number(raw)
+            const n = Number(raw.trim())
             if (!Number.isFinite(n)) throw new Error(`${env} expects a JSON number, got '${raw}'.`)
             return n
         }
@@ -129,6 +143,13 @@ function coerceScalar(raw: string, type: 'bool' | 'number' | 'string', env: stri
     }
 }
 
+const SECRET_ENVS = new Set(ENV_OVERRIDES.filter(entry => entry.secret).map(entry => entry.env))
+
+// Applied overrides get logged, and some of them are webhook URLs and bot tokens.
+export function describeOverrideValue(envName: string, value: unknown): string {
+    return SECRET_ENVS.has(envName) ? '***' : JSON.stringify(value)
+}
+
 export interface ComputedOverride {
     env: string
     path: string
@@ -169,6 +190,26 @@ export function computeOverrides(env: NodeJS.ProcessEnv = process.env): {
     return { applied, errors }
 }
 
+export interface MergeReport {
+    forced: { path: string; value: unknown }[]
+    applied: ComputedOverride[]
+    errors: OverrideError[]
+}
+
+// Merges CONFIG_* overrides into an already-parsed config object. loadConfig()
+// calls this on every start so a launcher (Web UI, scheduler, plain shell) only
+// has to set the env var - nothing has to rewrite config.json first.
+// Unlike applyEnvOverrides this is not all-or-nothing: valid overrides still
+// land and the caller decides how loudly to report the rejected ones.
+export function mergeEnvOverrides(config: Record<string, unknown>, env: NodeJS.ProcessEnv = process.env): MergeReport {
+    const { applied, errors } = computeOverrides(env)
+    const forced = forcedOverrides(env)
+    // applied first, forced last: FORCE_HEADLESS pins headless on and CONFIG_HEADLESS cannot undo it
+    for (const { path: p, value } of applied) setDeep(config, p, value)
+    for (const { path: p, value } of forced) setDeep(config, p, value)
+    return { forced, applied, errors }
+}
+
 export interface ApplyReport {
     configPath: string
     forced: { path: string; value: unknown }[]
@@ -177,18 +218,19 @@ export interface ApplyReport {
 }
 
 export function applyEnvOverrides(configPath: string, env: NodeJS.ProcessEnv = process.env): ApplyReport {
-    const { applied, errors } = computeOverrides(env)
-    if (errors.length > 0) {
-        return { configPath, forced: [], applied: [], errors }
+    // Preflight before touching the file: a single bad value must not leave a
+    // half-overridden config.json behind.
+    const { errors: rejected } = computeOverrides(env)
+    if (rejected.length > 0) {
+        return { configPath, forced: [], applied: [], errors: rejected }
     }
 
     const config = readJson(configPath) as Record<string, unknown>
-    for (const { path: p, value } of FORCED_OVERRIDES) setDeep(config, p, value)
-    for (const { path: p, value } of applied) setDeep(config, p, value)
+    const { applied, forced } = mergeEnvOverrides(config, env)
 
     writeConfigAtomic(configPath, config, { backup: false })
 
-    return { configPath, forced: FORCED_OVERRIDES, applied, errors: [] }
+    return { configPath, forced, applied, errors: [] }
 }
 
 // ── CLI entry point, used by entrypoint.sh ──
@@ -269,7 +311,9 @@ Examples:
                 process.exit(1)
             }
             report.forced.forEach(f => console.log(`[entrypoint]   .${f.path} = ${f.value} (forced)`))
-            report.applied.forEach(a => console.log(`[entrypoint]   .${a.path} = ${JSON.stringify(a.value)}`))
+            report.applied.forEach(a =>
+                console.log(`[entrypoint]   .${a.path} = ${describeOverrideValue(a.env, a.value)}`)
+            )
             console.log(`[entrypoint] Applied ${report.applied.length} override(s).`)
             process.exit(0)
         } catch (err) {
diff --git a/src/util/Load.ts b/src/util/Load.ts
index 71b4400e..9b5edcfa 100644
--- a/src/util/Load.ts
+++ b/src/util/Load.ts
@@ -3,6 +3,7 @@ import path from 'path'
 
 import type { Account, AccountProxy, ConfigSaveFingerprint } from '../interface/Account'
 import type { Config } from '../interface/Config'
+import { describeOverrideValue, mergeEnvOverrides } from './ConfigEnvOverrides'
 import { validateAccounts, validateConfig } from './Validator'
 
 let configCache: Config
@@ -154,6 +155,24 @@ export function loadAccounts(): Account[] {
     }
 }
 
+function applyConfigEnvOverrides(rawConfig: unknown): void {
+    if (typeof rawConfig !== 'object' || rawConfig === null || Array.isArray(rawConfig)) return
+
+    const { applied, forced, errors } = mergeEnvOverrides(rawConfig as Record<string, unknown>)
+
+    // Loud on both sides: a silently ignored toggle is exactly the bug this fixes,
+    // and a rejected value would otherwise look identical to the feature being off.
+    for (const { env, path: dotted, value } of applied) {
+        console.log(`[Config] override: ${env} -> .${dotted} = ${describeOverrideValue(env, value)}`)
+    }
+    for (const { path: dotted, value } of forced) {
+        console.log(`[Config] override: .${dotted} = ${JSON.stringify(value)} (forced)`)
+    }
+    for (const { message } of errors) {
+        console.warn(`[Config] WARN: ignored invalid override - ${message}`)
+    }
+}
+
 export function loadConfig(): Config {
     try {
         if (configCache) {
@@ -170,6 +189,14 @@ export function loadConfig(): Config {
         const config = fs.readFileSync(configPath, 'utf-8')
 
         const unverifiedConfig = JSON.parse(config)
+
+        // CONFIG_* overrides are merged here rather than written to config.json,
+        // so every launcher (Web UI, scheduler, plain shell, Docker) gets them by
+        // setting an env var. Runs before validateConfig so overridden values go
+        // through the same schema checks as file values.
+        ensureEnvLoaded()
+        applyConfigEnvOverrides(unverifiedConfig)
+
         const configData = validateConfig(unverifiedConfig)
 
         configCache = configData
diff --git a/tests/abort.test.mjs b/tests/abort.test.mjs
new file mode 100644
index 00000000..f5085f88
--- /dev/null
+++ b/tests/abort.test.mjs
@@ -0,0 +1,114 @@
+/**
+ * Self-check for the run-abort path.
+ *
+ * Run: node --test tests/abort.test.js
+ *
+ * Covers the two things that actually break in the wild:
+ *   1. abortRun() closes every registered browser, so none survive a Stop.
+ *   2. ProcessManager.stop() asks for a graceful abort before killing the tree,
+ *      because a bare taskkill leaves the bot no chance to close Chromium.
+ */
+
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { ABORT_SENTINEL, ProcessManager } from '../scripts/api/processManager.js'
+
+test('abortRun closes every registered browser and flips the signal', async () => {
+    // Import through dist so this runs without a TS loader.
+    const { abortRun, abortSignal, isAborted, registerBrowser } = await import('../dist/util/Abort.js')
+
+    const closed = []
+    const fakeBrowser = name => ({
+        close: async () => {
+            closed.push(name)
+        }
+    })
+
+    registerBrowser(fakeBrowser('mobile'))
+    registerBrowser(fakeBrowser('desktop'))
+
+    assert.equal(isAborted(), false, 'signal should start un-aborted')
+
+    const count = await abortRun()
+
+    assert.equal(count, 2, 'should report both browsers closed')
+    assert.deepEqual(closed.sort(), ['desktop', 'mobile'])
+    assert.equal(abortSignal.aborted, true, 'signal must flip so loops bail out')
+    assert.equal(isAborted(), true)
+
+    // Idempotent: a second Stop click must not throw or double-close.
+    assert.equal(await abortRun(), 0)
+})
+
+test('a browser that fails to close does not break the abort', async () => {
+    const { abortRun, registerBrowser } = await import('../dist/util/Abort.js')
+
+    registerBrowser({
+        close: async () => {
+            throw new Error('browser already gone')
+        }
+    })
+
+    // Must resolve, not reject - a dead browser is the outcome we wanted anyway.
+    assert.equal(await abortRun(), 1)
+})
+
+test('stop() requests a graceful abort before killing the tree', async () => {
+    const pm = new ProcessManager({
+        command: process.execPath,
+        // Ignores stdin and stays alive, so we can observe the abort request.
+        args: ['-e', 'setTimeout(() => {}, 60_000)'],
+        cwd: process.cwd(),
+        stopTimeoutMs: 1500
+    })
+
+    pm.start()
+    await new Promise(resolve => pm.once('status', resolve))
+
+    const written = []
+    const realWrite = pm.child.stdin.write.bind(pm.child.stdin)
+    pm.child.stdin.write = chunk => {
+        written.push(String(chunk))
+        return realWrite(chunk)
+    }
+
+    const exit = pm.stop({ force: false })
+
+    assert.ok(
+        written.some(chunk => chunk.includes(ABORT_SENTINEL)),
+        'stop() should write the abort sentinel to stdin'
+    )
+
+    // The child ignores the sentinel, so the kill timer must still finish the job.
+    await exit
+    assert.equal(pm.getStatus().state, 'idle', 'server must settle back to idle, not hang')
+})
+
+test('force stop skips the graceful path', async () => {
+    const pm = new ProcessManager({
+        command: process.execPath,
+        args: ['-e', 'setTimeout(() => {}, 60_000)'],
+        cwd: process.cwd(),
+        stopTimeoutMs: 1500
+    })
+
+    pm.start()
+    await new Promise(resolve => pm.once('status', resolve))
+
+    const written = []
+    const realWrite = pm.child.stdin.write.bind(pm.child.stdin)
+    pm.child.stdin.write = chunk => {
+        written.push(String(chunk))
+        return realWrite(chunk)
+    }
+
+    await pm.stop({ force: true })
+
+    assert.equal(
+        written.some(chunk => chunk.includes(ABORT_SENTINEL)),
+        false,
+        'force stop should kill immediately without asking'
+    )
+    assert.equal(pm.getStatus().state, 'idle')
+})
diff --git a/tests/accountProxy.test.mjs b/tests/accountProxy.test.mjs
new file mode 100644
index 00000000..0ae142a2
--- /dev/null
+++ b/tests/accountProxy.test.mjs
@@ -0,0 +1,236 @@
+/**
+ * Regression cover for Web UI proxy editing.
+ *
+ * Run: node --test tests/accountProxy.test.mjs
+ *
+ * The rules asserted here mirror src/util/Validator.ts (AccountProxySchema) and
+ * src/util/Proxy.ts. If the API accepted something the bot rejects, the next run
+ * would die at account validation with no hint that the UI was the cause.
+ */
+
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import test from 'node:test'
+
+const { readAccountProxy, validateProxyInput, writeAccountProxy, parseProxyUrl } =
+    await import('../scripts/api/accountProxy.js')
+
+function tempRoot(envBody = '') {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'proxy-test-'))
+    if (envBody) fs.writeFileSync(path.join(dir, '.env'), envBody)
+    return dir
+}
+
+function readEnv(root) {
+    return fs.readFileSync(path.join(root, '.env'), 'utf8')
+}
+
+// ── URL parsing ──
+
+test('a bare hostname is treated as http, matching the bot', () => {
+    const parsed = parseProxyUrl('proxy.example.com')
+    assert.equal(parsed.protocol, 'http:')
+    assert.equal(parsed.hostname, 'proxy.example.com')
+})
+
+test('all four browser protocols are accepted', () => {
+    for (const scheme of ['http', 'https', 'socks4', 'socks5']) {
+        const parsed = parseProxyUrl(`${scheme}://proxy.example.com`)
+        assert.equal(parsed.protocol, `${scheme}:`)
+    }
+})
+
+test('unsupported protocols are rejected with a helpful message', () => {
+    assert.throws(() => parseProxyUrl('ftp://proxy.example.com'), /Unsupported proxy protocol/)
+})
+
+test('a malformed URL is rejected', () => {
+    assert.throws(() => parseProxyUrl('http://'), /Invalid proxy URL/)
+})
+
+// ── Validation rules ──
+
+test('a disabled proxy needs no URL and clears every field', () => {
+    const proxy = validateProxyInput({ url: '', proxyHttp: false })
+    assert.deepEqual(proxy, { proxyHttp: false, url: '', port: 0, username: '', password: '' })
+})
+
+test('a port without a URL is rejected, as the bot rejects it', () => {
+    assert.throws(() => validateProxyInput({ url: '', port: 8080 }), /Proxy URL is required/)
+})
+
+test('credentials in the URL are rejected', () => {
+    assert.throws(
+        () => validateProxyInput({ url: 'http://user:pass@proxy.example.com', port: 8080 }),
+        /username\/password fields/
+    )
+})
+
+test('a missing or out-of-range port is rejected', () => {
+    assert.throws(() => validateProxyInput({ url: 'http://p.example.com' }), /port must be an integer/)
+    assert.throws(() => validateProxyInput({ url: 'http://p.example.com', port: 70000 }), /port must be an integer/)
+    assert.throws(() => validateProxyInput({ url: 'http://p.example.com', port: 0 }), /port must be an integer/)
+})
+
+test('a username without a password is rejected', () => {
+    assert.throws(
+        () => validateProxyInput({ url: 'http://p.example.com', port: 8080, username: 'user' }),
+        /configured together/
+    )
+})
+
+test('SOCKS proxies cannot use authentication', () => {
+    assert.throws(
+        () => validateProxyInput({ url: 'socks5://p.example.com', port: 1080, username: 'u', password: 'p' }),
+        /not supported by Patchright/
+    )
+})
+
+test('an authenticated HTTP proxy is accepted and normalised', () => {
+    const proxy = validateProxyInput({
+        url: 'https://Proxy.Example.com',
+        port: 8443,
+        username: 'user',
+        password: 'secret',
+        proxyHttp: true
+    })
+    assert.equal(proxy.url, 'https://proxy.example.com')
+    assert.equal(proxy.port, 8443)
+    assert.equal(proxy.username, 'user')
+    assert.equal(proxy.password, 'secret')
+    assert.equal(proxy.proxyHttp, true)
+})
+
+test('a blank password keeps the stored one when the username is unchanged', () => {
+    const existing = { hasPassword: true, username: 'user' }
+    const proxy = validateProxyInput({ url: 'http://p.example.com', port: 8080, username: 'user' }, existing)
+    assert.equal(proxy.password, null, 'null means keep what is on disk')
+})
+
+test('a blank password does not keep the old one when the username changed', () => {
+    const existing = { hasPassword: true, username: 'old-user' }
+    assert.throws(
+        () => validateProxyInput({ url: 'http://p.example.com', port: 8080, username: 'new-user' }, existing),
+        /configured together/
+    )
+})
+
+// ── .env read/write ──
+
+test('writing then reading a proxy round-trips', () => {
+    const root = tempRoot('ACCOUNT_1_EMAIL=a@example.com\n')
+
+    writeAccountProxy(root, 1, {
+        proxyHttp: true,
+        url: 'http://proxy.example.com',
+        port: 8080,
+        username: 'user',
+        password: 'secret'
+    })
+
+    const proxy = readAccountProxy(root, 1)
+    assert.equal(proxy.url, 'http://proxy.example.com')
+    assert.equal(proxy.port, 8080)
+    assert.equal(proxy.username, 'user')
+    assert.equal(proxy.hasPassword, true)
+    assert.equal(proxy.proxyHttp, true)
+})
+
+test('the password is never returned, only whether one exists', () => {
+    const root = tempRoot('ACCOUNT_1_EMAIL=a@example.com\n')
+    writeAccountProxy(root, 1, {
+        proxyHttp: false,
+        url: 'http://p.example.com',
+        port: 8080,
+        username: 'u',
+        password: 'topsecret'
+    })
+
+    const proxy = readAccountProxy(root, 1)
+    assert.equal('password' in proxy, false)
+    assert.equal(JSON.stringify(proxy).includes('topsecret'), false)
+})
+
+test('password: null preserves the stored password on disk', () => {
+    const root = tempRoot('ACCOUNT_1_EMAIL=a@example.com\n')
+    writeAccountProxy(root, 1, {
+        proxyHttp: false,
+        url: 'http://p.example.com',
+        port: 8080,
+        username: 'u',
+        password: 'keepme'
+    })
+
+    writeAccountProxy(root, 1, {
+        proxyHttp: false,
+        url: 'http://p.example.com',
+        port: 9090,
+        username: 'u',
+        password: null
+    })
+
+    assert.match(readEnv(root), /ACCOUNT_1_PROXY_PASSWORD=keepme/)
+    assert.equal(readAccountProxy(root, 1).port, 9090)
+})
+
+test('saving twice edits lines in place instead of appending duplicates', () => {
+    const root = tempRoot('ACCOUNT_1_EMAIL=a@example.com\n')
+    const proxy = { proxyHttp: false, url: 'http://p.example.com', port: 8080, username: '', password: '' }
+    writeAccountProxy(root, 1, proxy)
+    writeAccountProxy(root, 1, proxy)
+
+    const env = readEnv(root)
+    for (const suffix of ['PROXY_HTTP', 'PROXY_URL', 'PROXY_PORT', 'PROXY_USERNAME', 'PROXY_PASSWORD']) {
+        const hits = env.split('\n').filter(line => line.startsWith(`ACCOUNT_1_${suffix}=`))
+        assert.equal(hits.length, 1, `${suffix} should appear exactly once`)
+    }
+})
+
+test('the account email line is left intact', () => {
+    const root = tempRoot('ACCOUNT_1_EMAIL=keep@example.com\n')
+    writeAccountProxy(root, 1, { proxyHttp: false, url: '', port: 0, username: '', password: '' })
+    assert.match(readEnv(root), /ACCOUNT_1_EMAIL=keep@example\.com/)
+})
+
+test('commentator example lines are not treated as configuration', () => {
+    const root = tempRoot('#ACCOUNT_1_PROXY_URL=\nACCOUNT_1_EMAIL=a@example.com\n')
+    assert.equal(readAccountProxy(root, 1).url, '')
+})
+
+test('accounts are independent of one another', () => {
+    const root = tempRoot('ACCOUNT_1_EMAIL=a@example.com\nACCOUNT_2_EMAIL=b@example.com\n')
+    writeAccountProxy(root, 2, {
+        proxyHttp: false,
+        url: 'http://two.example.com',
+        port: 3128,
+        username: '',
+        password: ''
+    })
+
+    assert.equal(readAccountProxy(root, 1).url, '')
+    assert.equal(readAccountProxy(root, 2).url, 'http://two.example.com')
+})
+
+test('a cleared proxy reads back as disabled', () => {
+    const root = tempRoot('ACCOUNT_1_EMAIL=a@example.com\n')
+    writeAccountProxy(root, 1, { proxyHttp: false, url: '', port: 0, username: '', password: '' })
+
+    const proxy = readAccountProxy(root, 1)
+    assert.equal(proxy.url, '')
+    assert.equal(proxy.port, 0)
+    assert.equal(proxy.proxyHttp, false)
+    assert.equal(proxy.hasPassword, false)
+})
+
+test('PROXY_HTTP accepts the same boolean words the bot accepts', () => {
+    for (const word of ['1', 'true', 'yes', 'on', 'TRUE']) {
+        const root = tempRoot(`ACCOUNT_1_EMAIL=a@example.com\nACCOUNT_1_PROXY_HTTP=${word}\n`)
+        assert.equal(readAccountProxy(root, 1).proxyHttp, true, `${word} should mean true`)
+    }
+    for (const word of ['0', 'false', 'no', 'off']) {
+        const root = tempRoot(`ACCOUNT_1_EMAIL=a@example.com\nACCOUNT_1_PROXY_HTTP=${word}\n`)
+        assert.equal(readAccountProxy(root, 1).proxyHttp, false, `${word} should mean false`)
+    }
+})
diff --git a/tests/configEnvOverrides.test.mjs b/tests/configEnvOverrides.test.mjs
new file mode 100644
index 00000000..9245c259
--- /dev/null
+++ b/tests/configEnvOverrides.test.mjs
@@ -0,0 +1,133 @@
+/**
+ * Regression cover for CONFIG_* env overrides reaching the running bot.
+ *
+ * Run: node --test tests/configEnvOverrides.test.mjs
+ *
+ * The bug this guards: the Web UI toggles Visual Search / Edge Browsing by
+ * setting CONFIG_WORKER_VISUAL_SEARCH and CONFIG_EXPERIMENTAL_EDGE_BROWSING on
+ * the spawned run, but nothing merged those vars into the config the bot
+ * evaluated. Only the Docker entrypoint applied them (by rewriting config.json),
+ * so a locally launched run silently skipped both features.
+ */
+
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+// Import through dist so this runs without a TS loader.
+const { mergeEnvOverrides, computeOverrides, describeOverrideValue } =
+    await import('../dist/util/ConfigEnvOverrides.js')
+
+function baseConfig() {
+    return {
+        headless: true,
+        clusters: 1,
+        workers: { doVisualSearch: false, doDailySet: true },
+        experimental: { edgeBrowsing: false, apiSearch: false }
+    }
+}
+
+test('the two toggled features land on the config the bot reads', () => {
+    const config = baseConfig()
+    // Exactly what public/app.js puts in the /start payload.
+    const report = mergeEnvOverrides(config, {
+        CONFIG_WORKER_VISUAL_SEARCH: 'true',
+        CONFIG_EXPERIMENTAL_EDGE_BROWSING: 'true'
+    })
+
+    assert.equal(config.workers.doVisualSearch, true)
+    assert.equal(config.experimental.edgeBrowsing, true)
+    assert.equal(report.errors.length, 0)
+    assert.deepEqual(report.applied.map(entry => entry.path).sort(), [
+        'experimental.edgeBrowsing',
+        'workers.doVisualSearch'
+    ])
+})
+
+test('toggling off overrides a config.json that has the feature on', () => {
+    const config = baseConfig()
+    config.workers.doVisualSearch = true
+    config.experimental.edgeBrowsing = true
+
+    mergeEnvOverrides(config, {
+        CONFIG_WORKER_VISUAL_SEARCH: 'false',
+        CONFIG_EXPERIMENTAL_EDGE_BROWSING: 'false'
+    })
+
+    assert.equal(config.workers.doVisualSearch, false)
+    assert.equal(config.experimental.edgeBrowsing, false)
+})
+
+test('unset vars leave the file values alone', () => {
+    const config = baseConfig()
+    config.workers.doVisualSearch = true
+
+    const report = mergeEnvOverrides(config, {})
+
+    assert.equal(config.workers.doVisualSearch, true)
+    assert.equal(report.applied.length, 0)
+})
+
+test('an empty string is treated as unset, not as false', () => {
+    const config = baseConfig()
+    config.workers.doVisualSearch = true
+
+    mergeEnvOverrides(config, { CONFIG_WORKER_VISUAL_SEARCH: '' })
+
+    assert.equal(config.workers.doVisualSearch, true)
+})
+
+test('shell-style booleans are accepted, not just true/false', () => {
+    for (const raw of ['1', 'yes', 'on', 'TRUE', ' true ']) {
+        const config = baseConfig()
+        mergeEnvOverrides(config, { CONFIG_WORKER_VISUAL_SEARCH: raw })
+        assert.equal(config.workers.doVisualSearch, true, `${JSON.stringify(raw)} should mean true`)
+    }
+
+    for (const raw of ['0', 'no', 'off', 'FALSE']) {
+        const config = baseConfig()
+        config.workers.doVisualSearch = true
+        mergeEnvOverrides(config, { CONFIG_WORKER_VISUAL_SEARCH: raw })
+        assert.equal(config.workers.doVisualSearch, false, `${JSON.stringify(raw)} should mean false`)
+    }
+})
+
+test('one bad value does not discard the valid overrides beside it', () => {
+    const config = baseConfig()
+    const report = mergeEnvOverrides(config, {
+        CONFIG_WORKER_VISUAL_SEARCH: 'true',
+        CONFIG_CLUSTERS: 'abc'
+    })
+
+    assert.equal(config.workers.doVisualSearch, true, 'valid override must still apply')
+    assert.equal(config.clusters, 1, 'rejected override must leave the file value')
+    assert.equal(report.errors.length, 1)
+    assert.equal(report.errors[0].env, 'CONFIG_CLUSTERS')
+})
+
+test('a rejected boolean is reported instead of silently passing', () => {
+    const { errors } = computeOverrides({ CONFIG_EXPERIMENTAL_EDGE_BROWSING: 'maybe' })
+    assert.equal(errors.length, 1)
+    assert.match(errors[0].message, /boolean/)
+})
+
+test('FORCE_HEADLESS wins over CONFIG_HEADLESS, and is off by default', () => {
+    const forced = baseConfig()
+    mergeEnvOverrides(forced, { CONFIG_HEADLESS: 'false', FORCE_HEADLESS: '1' })
+    assert.equal(forced.headless, true, 'containers have no display, so headless stays pinned')
+
+    // Outside Docker the user keeps control of headless.
+    const free = baseConfig()
+    mergeEnvOverrides(free, { CONFIG_HEADLESS: 'false' })
+    assert.equal(free.headless, false)
+})
+
+test('nested paths are created when config.json predates the key', () => {
+    const config = { headless: true }
+    mergeEnvOverrides(config, { CONFIG_EXPERIMENTAL_EDGE_BROWSING: 'true' })
+    assert.equal(config.experimental.edgeBrowsing, true)
+})
+
+test('secret override values are masked in the applied-override log', () => {
+    assert.equal(describeOverrideValue('CONFIG_DISCORD_URL', 'https://discord.com/api/webhooks/secret'), '***')
+    assert.equal(describeOverrideValue('CONFIG_WORKER_VISUAL_SEARCH', true), 'true')
+})
diff --git a/tests/sessionStatus.test.mjs b/tests/sessionStatus.test.mjs
new file mode 100644
index 00000000..7a5f8030
--- /dev/null
+++ b/tests/sessionStatus.test.mjs
@@ -0,0 +1,208 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { DatabaseSync } from 'node:sqlite'
+
+import { getSessionLoginStatusMap, listStoredSessions } from '../scripts/api/sessionStore.js'
+
+const SECOND = 1000
+const DAY_SECONDS = 24 * 60 * 60
+
+function secondsFromNow(days) {
+    return Math.floor(Date.now() / SECOND) + days * DAY_SECONDS
+}
+
+function storageState(cookies) {
+    return JSON.stringify({ cookies, origins: [] })
+}
+
+/**
+ * Builds a throwaway sessions.db that looks like the one the bot writes, then
+ * returns the (projectRoot, sessionPath) pair the API reader expects.
+ *
+ * sessionPath is randomized so resolveSessionDb cannot accidentally match the
+ * real ./sessions/sessions.db relative to the test process cwd.
+ */
+function makeSessionDb(rows) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'mrs-session-test-'))
+    const sessionPath = `sessions-${path.basename(root)}`
+    const dir = path.join(root, sessionPath)
+    fs.mkdirSync(dir, { recursive: true })
+
+    const db = new DatabaseSync(path.join(dir, 'sessions.db'))
+    db.exec(`
+        CREATE TABLE sessions (
+            email         TEXT NOT NULL,
+            platform      TEXT NOT NULL,
+            storage_state TEXT,
+            fingerprint   TEXT,
+            updated_at    INTEGER NOT NULL,
+            PRIMARY KEY (email, platform)
+        )
+    `)
+    const insert = db.prepare(
+        'INSERT INTO sessions (email, platform, storage_state, fingerprint, updated_at) VALUES (?, ?, ?, ?, ?)'
+    )
+    for (const row of rows) {
+        insert.run(
+            row.email,
+            row.platform,
+            row.storageState ?? null,
+            row.fingerprint ?? null,
+            row.updatedAt ?? Date.now()
+        )
+    }
+    db.close()
+
+    return { root, sessionPath, cleanup: () => fs.rmSync(root, { recursive: true, force: true }) }
+}
+
+test('a live Microsoft auth cookie reports logged-in', () => {
+    const { root, sessionPath, cleanup } = makeSessionDb([
+        {
+            email: 'live@example.com',
+            platform: 'desktop',
+            storageState: storageState([
+                { name: 'MSPAuth', domain: '.live.com', expires: secondsFromNow(365) },
+                { name: 'MUID', domain: '.bing.com', expires: secondsFromNow(365) }
+            ])
+        }
+    ])
+
+    try {
+        const map = getSessionLoginStatusMap(root, sessionPath)
+        assert.equal(map.get('live@example.com').status, 'logged-in')
+        assert.equal(map.get('live@example.com').liveAuthCookieCount, 1)
+    } finally {
+        cleanup()
+    }
+})
+
+test('anonymous cookies alone are not proof of login', () => {
+    const { root, sessionPath, cleanup } = makeSessionDb([
+        {
+            email: 'anon@example.com',
+            platform: 'desktop',
+            storageState: storageState([
+                { name: 'MUID', domain: '.bing.com', expires: secondsFromNow(365) },
+                { name: 'SRCHHPGUSR', domain: '.bing.com', expires: secondsFromNow(365) }
+            ])
+        }
+    ])
+
+    try {
+        assert.equal(getSessionLoginStatusMap(root, sessionPath).get('anon@example.com').status, 'expired')
+    } finally {
+        cleanup()
+    }
+})
+
+test('an expired auth cookie reports expired, not logged-in', () => {
+    const { root, sessionPath, cleanup } = makeSessionDb([
+        {
+            email: 'stale@example.com',
+            platform: 'desktop',
+            storageState: storageState([{ name: '_U', domain: '.bing.com', expires: secondsFromNow(-2) }])
+        }
+    ])
+
+    try {
+        const info = getSessionLoginStatusMap(root, sessionPath).get('stale@example.com')
+        assert.equal(info.status, 'expired')
+        assert.equal(info.liveAuthCookieCount, 0)
+    } finally {
+        cleanup()
+    }
+})
+
+test('a session cookie (expires -1) still counts as live', () => {
+    const { root, sessionPath, cleanup } = makeSessionDb([
+        {
+            email: 'session-cookie@example.com',
+            platform: 'mobile',
+            storageState: storageState([{ name: 'WLSSC', domain: '.live.com', expires: -1 }])
+        }
+    ])
+
+    try {
+        assert.equal(getSessionLoginStatusMap(root, sessionPath).get('session-cookie@example.com').status, 'logged-in')
+    } finally {
+        cleanup()
+    }
+})
+
+test('a row with no storage state reports not-logged-in', () => {
+    const { root, sessionPath, cleanup } = makeSessionDb([
+        { email: 'empty@example.com', platform: 'desktop', storageState: null }
+    ])
+
+    try {
+        assert.equal(getSessionLoginStatusMap(root, sessionPath).get('empty@example.com').status, 'not-logged-in')
+    } finally {
+        cleanup()
+    }
+})
+
+test('the best platform wins when desktop and mobile disagree', () => {
+    const { root, sessionPath, cleanup } = makeSessionDb([
+        {
+            email: 'mixed@example.com',
+            platform: 'desktop',
+            storageState: storageState([{ name: 'MSPAuth', domain: '.live.com', expires: secondsFromNow(-1) }]),
+            updatedAt: Date.now() - 60_000
+        },
+        {
+            email: 'mixed@example.com',
+            platform: 'mobile',
+            storageState: storageState([{ name: 'MSPAuth', domain: '.live.com', expires: secondsFromNow(30) }]),
+            updatedAt: Date.now()
+        }
+    ])
+
+    try {
+        assert.equal(getSessionLoginStatusMap(root, sessionPath).get('mixed@example.com').status, 'logged-in')
+    } finally {
+        cleanup()
+    }
+})
+
+test('email lookups are case-insensitive', () => {
+    const { root, sessionPath, cleanup } = makeSessionDb([
+        {
+            email: 'MixedCase@Example.com',
+            platform: 'desktop',
+            storageState: storageState([{ name: 'MSPProf', domain: '.live.com', expires: secondsFromNow(10) }])
+        }
+    ])
+
+    try {
+        assert.equal(getSessionLoginStatusMap(root, sessionPath).get('mixedcase@example.com').status, 'logged-in')
+    } finally {
+        cleanup()
+    }
+})
+
+test('corrupt storage state is reported as expired rather than throwing', () => {
+    const { root, sessionPath, cleanup } = makeSessionDb([
+        { email: 'corrupt@example.com', platform: 'desktop', storageState: '{not json' }
+    ])
+
+    try {
+        const listed = listStoredSessions(root, sessionPath)
+        assert.equal(listed.sessions[0].parseError, true)
+        assert.equal(getSessionLoginStatusMap(root, sessionPath).get('corrupt@example.com').status, 'expired')
+    } finally {
+        cleanup()
+    }
+})
+
+test('a missing database yields null so callers can leave status untouched', () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'mrs-session-missing-'))
+    try {
+        assert.equal(getSessionLoginStatusMap(root, `sessions-${path.basename(root)}`), null)
+    } finally {
+        fs.rmSync(root, { recursive: true, force: true })
+    }
+})