release: v0.38.4 — exclude ambient gh token from provider detection (#159)

Co-authored-by: Nathan Esquenazi <nesquena@gmail.com>

.dockerignore

@@ -0,0 +1,7 @@
+.git
+.pytest_cache
+__pycache__
+*.pyc
+*.pyo
+tests/
+.env*

.env.example

@@ -26,3 +26,6 @@
 
 # Path to your Hermes config.yaml (for toolsets and model config)
 # HERMES_CONFIG_PATH=~/.hermes/config.yaml
+
+# Display name for the assistant in the UI (default: Hermes)
+# HERMES_WEBUI_BOT_NAME=Hermes

.github/workflows/release.yml

@@ -0,0 +1,56 @@
+name: Release & Docker
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write   # required: create GitHub Release
+      packages: write   # required: push to ghcr.io
+
+    steps:
+      - uses: actions/checkout@v4
+
+      # Create GitHub Release from tag with auto-generated notes
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          generate_release_notes: true
+
+      # Set up multi-arch build (QEMU + Buildx)
+      - uses: docker/setup-qemu-action@v3
+      - uses: docker/setup-buildx-action@v3
+
+      # Log in to GitHub Container Registry
+      - name: Log in to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      # Extract tags from the git ref (supports vX.Y and vX.Y.Z formats)
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ghcr.io/${{ github.repository }}
+          tags: |
+            type=match,pattern=v(\d+\.\d+(?:\.\d+)?),group=1
+            type=raw,value=latest
+
+      # Build and push multi-arch image (amd64 + arm64)
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

ARCHITECTURE.md

@@ -18,7 +18,7 @@ a central chat area, and a right panel for workspace file browsing.
 
 The design philosophy is deliberately minimal. There is no build step, no bundler, no
 frontend framework. The Python server is split into a routing shell (server.py) and
-business logic modules (api/). The frontend is six vanilla JS modules loaded from static/.
+business logic modules (api/). The frontend is seven vanilla JS modules loaded from static/.
 This makes the code easy to modify from a terminal or by an agent.
 
 ---
@@ -26,38 +26,44 @@ This makes the code easy to modify from a terminal or by an agent.
 ## 2. File Inventory
 
     <repo>/
-    server.py              Thin routing shell + HTTP Handler. ~76 lines. Pure Python.
+    server.py              Thin routing shell + HTTP Handler + auth middleware. ~81 lines.
                            Delegates all route handling to api/routes.py.
     start.sh               Discovery script: finds agent dir, Python, starts server.
+    Dockerfile             python:3.12-slim container image (~23 lines)
+    docker-compose.yml     Compose config with named volume and optional auth (~22 lines)
+    .dockerignore          Excludes .git, tests/, .env* from Docker builds
     api/
       __init__.py          Package marker
-      routes.py            All GET + POST route handlers (~802 lines)
-      config.py            Shared configuration, constants, global state, model discovery (~453 lines)
-      helpers.py           HTTP helpers: j(), bad(), require(), safe_resolve() (~57 lines)
-      models.py            Session model + CRUD (~114 lines)
+      auth.py              Optional password authentication, signed cookies (~149 lines)
+      config.py            Discovery, globals, model detection, reloadable config (~701 lines)
+      helpers.py           HTTP helpers: j(), bad(), require(), safe_resolve(), security headers (~71 lines)
+      models.py            Session model + CRUD, per-session profile tracking (~137 lines)
+      profiles.py          Profile state management, hermes_cli wrapper (~246 lines)
+      routes.py            All GET + POST route handlers (~1180 lines)
+      streaming.py         SSE engine, run_agent, cancel, HERMES_HOME save/restore (~236 lines)
+      upload.py            Multipart parser, file upload handler (~78 lines)
       workspace.py         File ops: list_dir, read_file_content, workspace helpers (~77 lines)
-      upload.py            Multipart parser, file upload handler (~77 lines)
-      streaming.py         SSE engine, run_agent integration, cancel support (~218 lines)
     static/
-      index.html           HTML template (served from disk)
-      style.css            All CSS
-      ui.js                DOM helpers, renderMd, tool cards, model dropdown (~671 lines)
-      workspace.js         File tree, preview, file ops (~168 lines)
-      sessions.js          Session CRUD, list rendering, search (~206 lines)
-      messages.js          send(), SSE event handlers, approval, transcript (~310 lines)
-      panels.js            Cron, skills, memory, workspace, todo, switchPanel (~600 lines)
-      boot.js              Event wiring + boot IIFE (~154 lines)
+      index.html           HTML template (~364 lines)
+      style.css            All CSS incl. mobile responsive (~670 lines)
+      ui.js                DOM helpers, renderMd, tool cards, model dropdown, file tree (~977 lines)
+      workspace.js         File preview, file ops, loadDir, clearPreview (~185 lines)
+      sessions.js          Session CRUD, list rendering, search, SVG icons, overlay actions (~533 lines)
+      messages.js          send(), SSE event handlers, approval, transcript (~297 lines)
+      panels.js            Cron, skills, memory, workspace, profiles, todo, settings (~974 lines)
+      commands.js          Slash command registry, parser, autocomplete dropdown (~156 lines)
+      boot.js              Event wiring, mobile nav, voice input, boot IIFE (~338 lines)
     tests/
       conftest.py          Isolated test server (port 8788, separate HERMES_HOME) (~240 lines)
-      test_sprint1-11.py   Feature tests per sprint (13 files)
-      test_regressions.py  Permanent regression gate
+      test_sprint{1-20b}.py Feature tests per sprint (21 files, 415 test functions)
+      test_regressions.py  Permanent regression gate (23 tests)
     AGENTS.md              Instruction file for agents working in this directory.
     ROADMAP.md             Feature and product roadmap document.
     SPRINTS.md             Forward sprint plan with CLI + Claude parity targets.
     ARCHITECTURE.md        THIS FILE.
     TESTING.md             Manual browser test plan and automated coverage reference.
     CHANGELOG.md           Release notes per sprint.
-    PORTABILITY.md         Portability design spec for download-and-run installs.
+    BUGS.md                Bug backlog and fixed items tracker.
     requirements.txt       Python dependencies.
     .env.example           Sample environment variable overrides.
 
@@ -67,7 +73,8 @@ State directory (runtime data, separate from source):
     sessions/          One JSON file per session: {session_id}.json
     workspaces.json    Registered workspaces list
     last_workspace.txt Last-used workspace path
-    settings.json      (future) User settings
+    settings.json      User settings (default model, workspace, send key, password hash)
+    projects.json      Session project groups (name, color, id)
 
 Log file:
 
@@ -91,6 +98,8 @@ Environment variables controlling behavior:
     HERMES_WEBUI_STATE_DIR         Where sessions/ folder lives
     HERMES_CONFIG_PATH             Path to ~/.hermes/config.yaml
     HERMES_WEBUI_DEFAULT_MODEL     Default LLM model string
+    HERMES_WEBUI_PASSWORD          Optional: enable password auth (off by default)
+    HERMES_HOME                    Base directory for Hermes state (~/.hermes by default)
 
 Test isolation environment variables (set by conftest.py):
 
@@ -109,6 +118,8 @@ Per-request environment variables (set by chat handler, restored after):
     HERMES_EXEC_ASK      Set to "1" to enable approval gate for dangerous commands.
     HERMES_SESSION_KEY   Set to session_id. The approval tool keys pending entries
                          by this value, enabling per-session approval state.
+    HERMES_HOME          Set to the active profile's directory before running agent.
+                         Saved and restored around each agent run.
 
 WARNING: These env vars are process-global. Two concurrent chat requests will clobber
 each other. This is safe only for single-user, single-concurrent-request use.
@@ -151,10 +162,14 @@ Session is a plain Python class (not a dataclass, not SQLAlchemy):
       session_id    hex string, 12 chars (uuid4().hex[:12])
       title         string, auto-set from first user message
       workspace     absolute path string, resolved at creation
-      model         OpenRouter model ID string (e.g. "anthropic/claude-sonnet-4.6")
+      model         model ID string (e.g. "anthropic/claude-sonnet-4.6")
       messages      list of OpenAI-format message dicts
       created_at    float Unix timestamp
       updated_at    float Unix timestamp, updated on every save()
+      pinned        bool, default False (Sprint 12)
+      archived      bool, default False (Sprint 14)
+      project_id    string or null, FK to projects.json (Sprint 15)
+      tool_calls    list of tool call dicts (Sprint 10)
 
     Key methods:
       path (property)  Returns SESSION_DIR/{session_id}.json
@@ -326,16 +341,20 @@ read_file_content(workspace, rel):
 ### 5.1 Structure
 
 The frontend is served from static/ as separate files: one HTML template, one CSS file,
-and six JavaScript modules (~2,025 lines total). External dependency: Prism.js from CDN
-(syntax highlighting, loaded async/deferred).
+and six JavaScript modules (~2,786 lines total). External dependencies: Prism.js (syntax
+highlighting) and Mermaid.js (diagrams) from CDN, both loaded async/deferred with SRI hashes.
 
 Six JS modules loaded in order at end of <body>:
-  1. ui.js       (~589 lines) DOM helpers, renderMd, tool card rendering, global state
-  2. workspace.js (~168 lines) File tree, preview, file operations
-  3. sessions.js  (~206 lines) Session CRUD, list rendering, search
-  4. messages.js  (~310 lines) send(), SSE event handlers, approval, transcript
-  5. panels.js    (~600 lines) Cron, skills, memory, workspace, todo, switchPanel
-  6. boot.js      (~152 lines) Event wiring + boot IIFE
+  1. ui.js       (~846 lines) DOM helpers, renderMd, tool card rendering, global state
+  2. workspace.js (~169 lines) File tree, preview, file operations
+  3. sessions.js  (~532 lines) Session CRUD, list rendering, search, SVG icons, overlay actions, project picker
+  4. messages.js  (~293 lines) send(), SSE event handlers, approval, transcript
+  5. panels.js    (~771 lines) Cron, skills, memory, workspace, todo, switchPanel
+  6. boot.js      (~175 lines) Event wiring + boot IIFE
+
+sessions.js defines an `ICONS` constant at module level with hardcoded SVG strings for all
+session action buttons (pin, unpin, folder, archive, unarchive, duplicate, trash). All icons
+inherit `currentColor` for consistent theming.
 
 Three-panel layout (in static/index.html):
 
@@ -406,25 +425,43 @@ Boot IIFE:
 
 ### 5.4 Markdown Renderer (renderMd)
 
-A hand-rolled regex chain. Processes in this order:
-1. Code blocks (``` lang ... ```) -> <pre><code> with language header
-2. Inline code (`...`) -> <code>
-3. Bold+italic (***..***) -> <strong><em>
-4. Bold (**...**) -> <strong>
-5. Italic (*...*) -> <em>
-6. Headings (# ## ###) -> <h1> <h2> <h3>
-7. Horizontal rules (---+) -> <hr>
-8. Blockquotes (> ...) -> <blockquote>
-9. Unordered lists (- or * or + at line start) -> <ul><li>
-10. Ordered lists (N. at line start) -> <ol><li>
-11. Links ([text](https://...)) -> <a href target=_blank>
-12. Paragraph wrapping: remaining double-newline-separated blocks -> <p>
+A hand-rolled regex chain with HTML safety. Processes in this order:
+
+Pre-pass (v0.18.1):
+0a. Stash fenced code blocks and backtick spans (fence_stash array)
+0b. Convert safe HTML tags to markdown equivalents:
+    <strong>/<b> -> **text**, <em>/<i> -> *text*, <code> -> `text`, <br> -> newline
+0c. Restore stashed code blocks
+
+Pipeline:
+1. Mermaid blocks (```mermaid ... ```) -> <div class="mermaid-block">
+2. Code blocks (``` lang ... ```) -> <pre><code> with language header
+3. Inline code (`...`) -> <code>
+4. Bold+italic (***..***) -> <strong><em>
+5. Bold (**...**) -> <strong>
+6. Italic (*...*) -> <em>
+7. Headings (# ## ###) -> <h1> <h2> <h3> (uses inlineMd() for content)
+8. Horizontal rules (---+) -> <hr>
+9. Blockquotes (> ...) -> <blockquote> (uses inlineMd() for content)
+10. Unordered lists (- or * or + at line start) -> <ul><li> (uses inlineMd())
+11. Ordered lists (N. at line start) -> <ol><li> (uses inlineMd())
+12. Links ([text](https://...)) -> <a href target=_blank>
+13. Tables (| col | col |) -> <table>
+14. Safety net: escape any HTML tag not in SAFE_TAGS allowlist via esc()
+15. Paragraph wrapping: remaining double-newline-separated blocks -> <p>
+
+inlineMd() helper (v0.18.1):
+    Processes inline bold/italic/code/links within list items, blockquotes,
+    and headings. Escapes unknown tags via SAFE_INLINE allowlist. Replaces
+    the old direct esc() calls which would double-escape pre-pass output.
+
+SAFE_TAGS allowlist:
+    strong, em, code, pre, h1-6, ul, ol, li, table, thead, tbody, tr, th,
+    td, hr, blockquote, p, br, a, div. Everything else is escaped.
 
 Known gaps:
-- Tables: not supported, render as plain text
 - Nested lists: single regex pass, multi-level indentation not handled
 - Mixed bold+link in same line: may produce garbled output
-- Inline HTML: not sanitized (esc() only runs on code content)
 
 ### 5.5 Model Chip Label (Fixed in Sprint 1)
 
@@ -604,26 +641,27 @@ Split server.py into a proper package. Completed across Sprints 4-10.
 Current structure:
 
     <repo>/
-      server.py               Entry point + HTTP Handler routing (~704 lines)
+      server.py               Entry point + HTTP Handler dispatch (~76 lines)
       api/
         __init__.py
-        config.py             Configuration, constants, global state (~273 lines)
+        routes.py             All GET + POST route handlers (~1016 lines)
+        config.py             Configuration, constants, global state, model discovery (~640 lines)
         helpers.py            HTTP helpers: j(), bad(), require(), safe_resolve() (~57 lines)
-        models.py             Session model + CRUD (~114 lines)
+        models.py             Session model + CRUD (~132 lines)
         workspace.py          File ops, workspace management (~77 lines)
         upload.py             Multipart parser, file upload handler (~77 lines)
-        streaming.py          SSE engine, run_agent, cancel support (~218 lines)
+        streaming.py          SSE engine, run_agent, cancel support (~222 lines)
       static/
         index.html            HTML document (served from disk)
-        style.css             All CSS
+        style.css             All CSS (~560 lines)
         ui.js, workspace.js, sessions.js, messages.js, panels.js, boot.js
       tests/
         conftest.py           Isolated test server on port 8788
-        test_sprint1-10.py    Feature tests per sprint (12 files)
+        test_sprint1-16.py    Feature tests per sprint (14 files)
         test_regressions.py   Permanent regression gate
 
-Remaining: server.py still has all 49 route handlers in one do_GET/do_POST class.
-Sprint 11 plans extracting these to api/routes.py, making server.py a ~50-line shell.
+Route extraction to api/routes.py completed in Sprint 11. server.py is now a ~76-line
+thin shell: Handler class with structured logging, dispatch to routes, and main().
 
 ### Phase B: Thread-Safe Request Context (Priority: Critical, Effort: Medium)
 
@@ -718,10 +756,10 @@ Optional password gate for non-SSH-tunnel deployments.
 
 ### Phase I: Test Infrastructure -- COMPLETE
 
-190 tests across 12 test files + regression gate. Isolated test server on port 8788
+289 tests across 14 test files + regression gate. Isolated test server on port 8788
 with separate HERMES_HOME, wiped per run. Production data never touched.
 
-Test files: `test_sprint1.py` through `test_sprint10.py`, `test_regressions.py`.
+Test files: `test_sprint1.py` through `test_sprint11.py`, `test_sprint16.py`, `test_regressions.py`.
 Fixtures in `conftest.py`: auto-cleanup, cron isolation, workspace reset.
 
 Remaining: no CI (GitHub Actions), no frontend tests (browser-based).

BUGS.md

@@ -0,0 +1,40 @@
+# Bugs Backlog
+
+This file tracks UI bugs and polish items. Fixed items are kept for reference.
+
+---
+
+## Open Bugs
+
+*No open bugs at this time.*
+
+---
+
+## Fixed
+
+### ~~Session title truncation / hover actions~~ -- Fixed (Sprint 16)
+
+- **Was:** Action icons reserved ~30px of space even when invisible, truncating titles.
+- **Fix:** Wrapped all action buttons in a `.session-actions` overlay container with `position:absolute`. Titles now use full available width. Actions appear on hover with a gradient fade from the right edge.
+
+### ~~Folder/project assignment interaction feels sticky~~ -- Fixed (Sprint 16)
+
+- **Was:** Folder icon stayed permanently visible (blue, 60% opacity) when a session belonged to a project.
+- **Fix:** Replaced `.has-project` persistent button with a colored left border matching the project color. The folder button now only appears in the hover overlay like all other actions.
+
+### ~~Project picker clipping and width~~ -- Fixed (v0.17.3)
+
+- **Was:** Picker was clipped by `overflow:hidden` on `.session-item` ancestors. With `position:fixed`, no containing block constrained width -- picker stretched to full viewport.
+- **Fix:** Dynamic width calculation (min 160px, max 220px). Event listener reordering. Cleanup sequence corrected. (PR #25)
+
+### ~~NameError crash in model discovery~~ -- Fixed (v0.17.3)
+
+- **Was:** `logger.debug()` called in custom endpoint `except` block, but `logger` was never imported in `config.py`. Every failed endpoint fetch crashed with `NameError`.
+- **Fix:** Replaced with silent `pass` -- unreachable endpoints are expected when no local LLM is configured. (PR #24)
+
+---
+
+## Notes
+
+- Sprint 16 replaced all emoji HTML entities with monochrome SVG line icons (`ICONS` constant in `sessions.js`).
+- All session action buttons now use the overlay pattern for consistent UX.

CHANGELOG.md

@@ -1,8 +1,951 @@
 # Hermes Web UI -- Changelog
 
 > Living document. Updated at the end of every sprint.
-> Source: <repo>/
-> Repository: https://github.com/<your-username>/hermes-webui
+> Repository: https://github.com/nesquena/hermes-webui
+
+---
+
+## [v0.38.4] — 2026-04-06
+
+### Fixed
+- **Copilot false positive in model dropdown** (#158): `list_available_providers()` reported Copilot as available on any machine with `gh` CLI auth, because the Copilot token resolver falls back to `gh auth token`. The dropdown now skips any provider whose credential source is `'gh auth token'` — only explicit, dedicated credentials count. Users with `GITHUB_TOKEN` explicitly set in their `.env` still see Copilot correctly.
+
+---
+
+## [v0.38.3] — 2026-04-06
+
+### Fixed
+- **Model dropdown shows only configured providers** (#155): Provider detection now uses `hermes_cli.models.list_available_providers()` — the same auth check the Hermes agent uses at runtime — instead of scanning raw API key env vars. The dropdown now reflects exactly what the user has configured (auth.json, credential pools, OAuth flows like Copilot). When no providers are detected, shows only the configured default model rather than a full generic list. Added `copilot` and `gemini` to the curated model lists. Falls back to env var scanning for standalone installs without hermes-agent.
+
+---
+
+## [v0.38.2] — 2026-04-06
+
+### Fixed
+- **Tool cards actually render on page reload** (#140, #153): PR #149 fixed the wrong filter — it updated `vis` but not `visWithIdx` (the loop that actually creates DOM rows), so anchor rows were never inserted. This PR fixes `visWithIdx`. Additionally, `streaming.py`'s `assistant_msg_idx` builder previously only scanned Anthropic content-array format and produced `idx=-1` for all OpenAI-format tool calls (the format used in saved sessions); it now handles both. As a final fallback, `renderMessages()` now builds tool card data directly from per-message `tool_calls` arrays when `S.toolCalls` is empty, covering historical sessions that predate session-level tool tracking.
+
+---
+
+## [v0.38.1] — 2026-04-06
+
+### Fixed
+- **Model selector duplicates** (#147, #151): When `config.yaml` sets `model.default` with a provider prefix (e.g. `anthropic/claude-opus-4.6`), the model dropdown no longer shows a duplicate entry alongside the existing bare-ID entry. The dedup check now normalizes both sides before comparing.
+- **Stale model labels** (#147, #151): Sessions created with models no longer in the current provider list now show `"ModelName (unavailable)"` in muted text with a tooltip, instead of appearing as a normal selectable option that would fail silently on send.
+
+---
+
+## [v0.38.0] — 2026-04-06
+
+### Fixed
+- **Multi-provider model routing (#138):** Non-default provider models now use `@provider:model` format. `resolve_model_provider()` routes them through `resolve_runtime_provider(requested=provider)` — no OpenRouter fallback for users with direct provider keys.
+- **Personalities from config.yaml (#139):** `/api/personalities` reads from `config.yaml` `agent.personalities` (the documented mechanism). Personality prompts pass via `agent.ephemeral_system_prompt`.
+- **Tool call cards survive page reload (#140):** Assistant messages with only `tool_use` content are no longer filtered from the render list, preserving anchor rows for tool card display.
+
+---
+
+## [v0.37.0] /personality command, model prefix routing fix, tool card reload fix
+*April 6, 2026 | 465 tests*
+
+### Features
+- **`/personality` slash command.** Set a per-session agent personality from `~/.hermes/personalities/<name>/SOUL.md`. The personality prompt is prepended to the system message for every turn. Use `/personality <name>` to activate, `/personality none` to clear, `/personality` (no args) to list available personalities. Backend: `GET /api/personalities`, `POST /api/personality/set`. (PR #143)
+
+### Bug Fixes
+- **Model dropdown routes non-default provider models correctly (#138).** When the active provider is `anthropic` and you pick a `minimax` model, its ID is now prefixed `minimax/MiniMax-M2.7` so `resolve_model_provider()` can route it through OpenRouter. Guards added: `active_provider=None` prevents all-providers-prefixed, case is normalised, shared `_PROVIDER_MODELS` list is no longer mutated by the default_model injector. (PR #142)
+- **Tool call cards persist correctly after page reload.** The reload rendering logic now anchors cards AFTER the triggering assistant row (not before the next one), handles multi-step chains sharing a filtered anchor in chronological order, and filters fallback anchor to assistant rows only. (PR #141)
+
+---
+
+## [v0.36.3] Configurable Assistant Name
+*April 6, 2026 | 449 tests*
+
+### Features
+- **Configurable bot name.** New "Assistant Name" field in Settings panel.
+  Display name updates throughout the UI: sidebar, topbar, message roles,
+  login page, browser tab title, and composer placeholder. Defaults to
+  "Hermes". Configurable via settings or `HERMES_WEBUI_BOT_NAME` env var.
+  Server-side sanitization prevents empty names and escapes HTML for the
+  login page. (PR #135, based on #131 by @TaraTheStar)
+
+---
+
+## [v0.36.2] OpenRouter model routing fix
+*April 5, 2026 | 440 tests*
+
+### Bug Fixes
+- **OpenRouter models sent without prefix, causing 404 (#116).** `resolve_model_provider()` was stripping the `openrouter/` prefix from model IDs (e.g. sending `free` instead of `openrouter/free`) when `config_provider == 'openrouter'`. OpenRouter requires the full `provider/model` path to route upstream correctly. Fixed with an early return that preserves the complete model ID for all OpenRouter configs. (#127)
+- Added 7 unit tests for `resolve_model_provider()` — first coverage on this function. Tests the regression, cross-provider routing, direct-API prefix stripping, bare models, and empty model.
+
+---
+
+## [v0.36.1] Login form Enter key fix
+*April 5, 2026 | 433 tests*
+
+### Bug Fixes
+- **Login form Enter key unreliable in some browsers (#124).** `onsubmit="return doLogin(event)"` returned a Promise (async functions always return a truthy Promise), which could let the browser fall through to native form submission. Fixed with `doLogin(event);return false` plus an explicit `onkeydown` Enter handler on the password input as belt-and-suspenders. (#125)
+
+---
+
+## [v0.36] Self-Update Checker with One-Click Update
+*April 5, 2026 | 433 tests*
+
+### Features
+- **Update checker.** Non-blocking background check on boot detects when the
+  WebUI or hermes-agent git repos are behind upstream. Blue banner shows
+  "WebUI: N updates, Agent: N updates available" with Update Now / Later.
+- **One-click update.** "Update Now" runs `git stash && git pull --ff-only &&
+  git stash pop` on each behind repo, then reloads the page. Concurrent update
+  attempts blocked via lock. Dirty working trees safely stashed and restored.
+- **Settings toggle.** "Check for updates" checkbox in Settings panel. Persisted
+  server-side. Disabled = no background fetch, no banner.
+- **30-minute cache.** Git fetch runs at most twice per hour regardless of tab
+  count. Results cached server-side with TTL.
+- **Session-scoped dismissal.** "Later" dismisses banner for the current tab
+  session (sessionStorage). New tabs get a fresh check.
+- **Test mode.** `?test_updates=1` URL param shows the banner with fake data
+  (localhost only) for UI testing without needing to actually be behind.
+
+### Architecture
+- New `api/updates.py`: `check_for_updates()`, `apply_update()`. Thread-safe
+  caching with `_cache_lock`. Concurrent apply blocked with `_apply_lock`.
+  Default branch auto-detected (master/main).
+- `api/routes.py`: `GET /api/updates/check`, `POST /api/updates/apply`.
+  Simulate endpoint gated to 127.0.0.1.
+- `static/ui.js`: `_showUpdateBanner()`, `dismissUpdate()`, `applyUpdates()`.
+- `static/boot.js`: fire-and-forget check on boot (does not block UI).
+- `api/config.py`: `check_for_updates` in settings defaults + bool keys.
+- Docker safe: all git ops gated by `.git` directory existence check.
+
+---
+
+## [v0.35.1] Model dropdown fixes
+*April 5, 2026 | 433 tests*
+
+### Bug Fixes
+- **Custom providers invisible in model dropdown (#117).** `cfg_base_url` was scoped inside a conditional block but referenced unconditionally, causing a `NameError` for users with a `base_url` in config.yaml. Fix: initialize to `''` before the block. (#118)
+- **Configured default model missing from dropdown (#116).** OpenRouter and other providers replaced the model list with a hardcoded fallback that didn't include `model.default` values like `openrouter/free` or custom local model names. Fix: after building all groups, inject the configured `default_model` at the top of its provider group if absent. (#119)
+
+---
+
+## [v0.35] Security hardening
+*April 5, 2026 | 433 tests*
+
+### Security fixes
+- **ENV race condition (HIGH):** Two concurrent sessions could interleave `os.environ` writes, clobbering workspace and session keys. Fixed with a global `_ENV_LOCK` in `streaming.py` that serializes the env save/restore block across all sessions. (#108)
+- **Predictable signing key (MEDIUM):** Session cookies were signed with `sha256(STATE_DIR)` -- deterministic and forgeable if the install path is known. Now generates a cryptographically random 32-byte key on first startup, persisted to `STATE_DIR/.signing_key` (chmod 600). (#108)
+- **Upload path traversal (MEDIUM):** Filenames like `..` survived the `[^\w.\-]` sanitization regex because dots are allowed. Fixed by rejecting dot-only filenames and validating the resolved path stays within the workspace sandbox via `safe_resolve_ws()`. (#108)
+- **Weak password hashing (MEDIUM):** Bare SHA-256 with a predictable salt replaced with PBKDF2-SHA256 at 600k iterations (OWASP recommendation) using the random signing key as salt. No new dependencies (stdlib `hashlib.pbkdf2_hmac`). (#108)
+
+**Breaking change:** Existing session cookies and password hashes are invalidated on first restart after upgrade. Users with password auth enabled will need to re-set their password.
+
+---
+
+## [v0.34.3] Light theme final polish
+*April 5, 2026 | 433 tests*
+
+### Bug Fixes
+- **Light theme: sidebar, role labels, chips, and interactive elements all broken.** Session titles were too faint, active session used washed-out gold, pin stars were near-invisible bright yellow, and all hover/border effects used dark-theme white `rgba(255,255,255,.XX)` values invisible on cream. Fixed with 46 scoped `[data-theme="light"]` selector overrides covering session items, role labels, project chips, topbar chips, composer, suggestions, tool cards, cron list, and more. (#105)
+- Active session now uses blue accent (`#2d6fa3`) for strong contrast. Pin stars use deep gold (`#996b15`). Role labels are solid and high contrast.
+
+---
+
+## [v0.34.2] Theme text colors
+*April 5, 2026 | 433 tests*
+
+### Bug Fixes
+- **Light mode text unreadable.** Bold text was hardcoded white (invisible on cream), italic was light purple on cream, inline code had a dark box on a light background. Fixed by introducing 5 new per-theme CSS variables (`--strong`, `--em`, `--code-text`, `--code-inline-bg`, `--pre-text`) defined for every theme. (#102)
+- Also replaced remaining `rgba(255,255,255,.08)` border references with `var(--border)`, and darkened light theme `--code-bg` slightly for better contrast.
+
+---
+
+## [v0.34.1] Theme variable polish
+*April 5, 2026 | 433 tests*
+
+### Bug Fixes
+- **All non-dark themes had broken surfaces, topbar, and dropdowns.** 30+ hardcoded dark-navy rgba/hex values in style.css were stuck on the Dark palette regardless of active theme. Fixed by introducing 7 new CSS variables (`--surface`, `--topbar-bg`, `--main-bg`, `--input-bg`, `--hover-bg`, `--focus-ring`, `--focus-glow`) defined per-theme, replacing every hardcoded reference. (#100)
+
+---
+
+## [v0.34] Sprint 26 -- Pluggable UI Themes
+*April 5, 2026 | 433 tests*
+
+### Features
+- **6 built-in themes.** Dark (default), Light, Slate, Solarized Dark, Monokai,
+  Nord. Defined as CSS variable overrides on `:root[data-theme="name"]` — the
+  entire UI adapts automatically.
+- **Theme picker in Settings.** Dropdown with instant live preview. Changes
+  apply immediately as you click through options.
+- **`/theme` slash command.** `/theme dark`, `/theme light`, etc.
+- **Theme persistence.** Saved server-side in `settings.json` and client-side
+  in `localStorage` for flicker-free loading on page refresh.
+- **Flash prevention.** Inline `<script>` in `<head>` reads localStorage before
+  the stylesheet loads — no flash of the wrong theme.
+- **Custom theme support.** Any theme name is accepted (no enum gate). Create a
+  `:root[data-theme="name"]` CSS block and it works. See `THEMES.md`.
+- **Unsaved changes guard.** Settings panel now tracks dirty state and shows a
+  "You have unsaved changes" bar with Save/Discard buttons when closing with
+  unpersisted changes. Theme preview reverts on discard.
+
+### Architecture
+- `static/style.css`: 6 theme blocks using CSS variable overrides. Light theme
+  includes scrollbar and selection overrides.
+- `static/commands.js`: `/theme` command with validation.
+- `static/panels.js`: Settings dirty tracking, revert-on-discard, unsaved bar.
+- `static/boot.js`: Theme applied from server settings on boot.
+- `api/config.py`: `theme` field in `_SETTINGS_DEFAULTS` (no enum gate).
+- `THEMES.md`: Full documentation for creating custom themes.
+
+### Tests
+- 9 new tests in `test_sprint26.py`: default theme, round-trip persistence for
+  all 6 built-in themes, custom theme acceptance, settings isolation.
+  Total: **433 tests**.
+
+---
+
+## [v0.33] /insights Sync + state.db Bridge Fix
+*April 5, 2026 | 424 tests*
+
+### Features
+- **Opt-in `/insights` sync.** New "Sync usage to /insights" setting (default: off). When enabled, after each turn the WebUI mirrors session token usage, cost, model, and title into `state.db` so `hermes /insights` includes browser session activity. (#92, #93)
+
+### Bug Fixes
+- **state_sync.py correctness fixes.** Three bugs in the initial implementation caught during code review: wrong class name (`HermesState` → `SessionDB`), wrong constructor argument type (`str` → `Path`), wrong title update method (`_execute_write` with bad signature → `set_session_title`). Also fixed a SQLite connection leak (persistent connection opened per call, never closed). (#95)
+
+---
+
+## [v0.32] Auto-Compaction Handling + /compact Command (Issue #90)
+*April 5, 2026 | 424 tests*
+
+### Features
+- **Auto-compaction detection.** When the agent's `run_conversation()` triggers
+  context compression and rotates the session ID, the WebUI detects the mismatch
+  and renames the session file + cache entry so messages don't split across files.
+- **`compressed` SSE event.** Frontend receives a notification when compression
+  fires, shows a system message ("Context was auto-compressed") and a toast.
+- **`/compact` slash command.** Type `/compact` to request the agent compress
+  the conversation context. Sends a natural-language message that triggers the
+  agent's compression preflight.
+- **Real context window data.** The context usage indicator now uses actual
+  `context_length`, `threshold_tokens`, and `last_prompt_tokens` from the agent's
+  compressor instead of the client-side model name lookup. Tooltip shows the
+  auto-compress threshold. Hides gracefully when the agent has no compressor.
+
+### Architecture
+- `api/streaming.py`: Session ID mismatch detection after `run_conversation()`,
+  file rename, SESSIONS cache update under lock, `compressed` SSE event,
+  `context_length`/`threshold_tokens`/`last_prompt_tokens` in usage dict.
+- `static/commands.js`: `/compact` command.
+- `static/messages.js`: `compressed` SSE event handler.
+- `static/ui.js`: `_syncCtxIndicator()` rewritten to use server-side compressor
+  data instead of client-side model estimates.
+
+---
+
+## [v0.31.2] CLI session delete fix
+*April 5, 2026 | 424 tests*
+
+### Bug Fixes
+- **CLI sessions could not be deleted from the sidebar.** The delete handler only
+  removed the WebUI JSON session file, so CLI-backed sessions came back on refresh.
+  Added `delete_cli_session(sid)` in `api/models.py` and call it from
+  `/api/session/delete` so the SQLite `state.db` row and messages are removed too.
+  (#87, #88)
+
+### Notes
+- The public test suite still passes at 424/424.
+- Issue #87 already had a comment confirming the root cause, so no new issue comment
+  was needed here.
+
+## [v0.31] UI Polish + Deployment Hardening
+*April 4, 2026 | 424 tests*
+
+### Bug Fixes
+- **Profile dropdown overlaps chat messages.** `.topbar` had no stacking context,
+  causing the dropdown to paint over `.messages`. Added `position:relative;z-index:10`
+  to `.topbar`. (#71)
+- **Workspace dropdown clipped by sidebar.** `.sidebar overflow:hidden` swallowed
+  the upward-opening workspace dropdown entirely. Changed to `overflow:visible`
+  (scroll lives on `.session-list`); added `position:relative;z-index:10` to
+  `.sidebar-bottom`. (#71)
+- **Slash-command autocomplete behind tool cards.** `.composer-wrap` had
+  `position:relative` but no `z-index`, letting tool cards bleed over it.
+  Added `z-index:10`. (#71)
+- **Skill picker clipped inside Settings modal.** `.settings-panel overflow-y:auto`
+  clipped the absolute-positioned skill picker. Moved scroll to `.settings-body`,
+  set panel to `overflow:visible`, raised skill picker to `z-index:1100`. (#71)
+- **CLI session badge blocks action buttons on hover.** Added
+  `.session-item.cli-session:hover::after { display:none }` so the gold "cli"
+  label hides on hover, making archive/delete/pin fully reachable. (#71)
+- **Workspace dropdown name and path crowded on same line.** `.ws-opt` was a plain
+  block with inline spans. Added `flex-direction:column;gap:4px` so name and path
+  stack cleanly. (#71)
+- **Both servers sharing same state directory.** `api/config.py` and `start.sh`
+  both defaulted to `~/.hermes/webui-mvp` (an internal dev name). Changed default
+  to `~/.hermes/webui` -- generic, appropriate for any deployment. Override with
+  `HERMES_WEBUI_STATE_DIR`. (#72, #73)
+
+---
+
+## [v0.30.1] CLI Session Bridge Fixes
+*April 4, 2026 | 424 tests*
+
+### Bug Fixes
+- **CLI sessions not appearing in sidebar.** Three frontend gaps: `sessions.js`
+  wasn't rendering CLI sessions (missing `is_cli_session` check in render loop),
+  sidebar click handler didn't trigger import, and the "cli" badge CSS selector
+  wasn't matching the rendered DOM structure. (#58)
+- **CLI bridge read wrong profile's state.db.** `get_cli_sessions()` resolved
+  `HERMES_HOME` at server launch time, not at call time. After a profile switch,
+  it kept reading the original profile's database. Now resolves dynamically via
+  `get_active_hermes_home()`. (#59)
+- **Silent SQL error swallowed all CLI sessions.** The `sessions` table in
+  `state.db` has no `profile` column — the query referenced `s.profile` which
+  caused a silent `OperationalError`. The `except Exception: return []` handler
+  swallowed it, returning zero CLI sessions. Removed the column reference and
+  added explicit column-existence checks. (#60)
+
+### Features
+- **"Show CLI sessions" toggle in Settings.** New checkbox in the Settings panel
+  to show/hide CLI sessions in the sidebar. Persisted server-side in
+  `settings.json` (`show_cli_sessions`, default `true`). When disabled, CLI
+  sessions are excluded from `/api/sessions` responses. (#61)
+
+---
+
+## [v0.30] CLI Session Bridge (Community: @thadreber-web)
+*April 4, 2026 | 424 tests*
+
+### Features
+- **CLI session bridge.** The WebUI now reads sessions from the hermes-agent's
+  SQLite store (`state.db`). CLI sessions appear in the sidebar with a gold
+  "cli" indicator badge. Click to import into the WebUI store with full message
+  history — replies then work through the normal agent pipeline.
+- **`/api/session/import_cli` endpoint.** Imports a CLI session into the WebUI
+  JSON store. Idempotent — returns existing session if already imported.
+  Derives title from first message, inherits active profile and workspace.
+- **`/api/sessions` merges CLI sessions.** Sidebar shows both WebUI and CLI
+  sessions sorted by last activity. Deduplication ensures WebUI sessions take
+  priority when the same session_id exists in both stores.
+- **CLI session fallback on `/api/session`.** If a session_id isn't found in
+  the WebUI store, falls back to reading from the CLI SQLite store.
+
+### Architecture
+- `api/models.py`: `get_cli_sessions()`, `get_cli_session_messages()`,
+  `import_cli_session()`. All use parameterized SQL queries and `with` for
+  connection management. Graceful fallback on missing sqlite3 or state.db.
+- `api/routes.py`: CLI fallback in GET `/api/session`, merged list in
+  GET `/api/sessions`, POST `/api/session/import_cli`.
+- `static/style.css`: `.cli-session` indicator styles (gold border + badge).
+
+---
+
+## [v0.29] Sprint 23: Agentic Transparency + Polish
+*April 4, 2026 | 424 tests*
+
+### Features
+
+- **Token/cost display.** Agent usage (input tokens, output tokens, estimated
+  cost) is now read after each conversation and persisted on the session.
+  A muted badge appears below the last assistant message when enabled.
+  Off by default — toggle via the Settings panel checkbox or `/usage` slash
+  command. Persists server-side across refreshes.
+
+- **Subagent delegation cards.** `subagent_progress` events now render with
+  a 🔀 icon and a blue indented left border to visually distinguish child
+  tool activity from parent tool calls. `delegate_task` cards display as
+  "Delegate task" with cleaner formatting.
+
+- **Skill picker in cron create form.** The "New Job" form now has a search
+  input + tag chip picker for attaching skills to cron jobs. Skills fetched
+  from `/api/skills`, filtered on keyup, added/removed as tag chips.
+  `submitCronCreate()` sends `skills` array in the POST body. Backend already
+  supported the field — this was a pure frontend gap.
+
+- **Skill linked files viewer.** Skill preview panel now renders a "Linked
+  Files" section below SKILL.md content when a skill has `references/`,
+  `templates/`, `scripts/`, or `assets/` subdirectories. Clicking a file
+  loads it in the preview panel with syntax highlighting.
+  New `file` query param on `GET /api/skills/content` serves linked files
+  with path traversal protection.
+
+- **Workspace tree state persists across refreshes.** Expanded directory
+  paths are saved to `localStorage` keyed by workspace path
+  (`hermes-webui-expanded:{path}`). On every root load (page refresh,
+  session switch), the saved state is restored and previously-expanded
+  directories are pre-fetched so the tree renders fully on first paint.
+
+- **Timestamps fixed.** `api/streaming.py` now stamps `timestamp` on every
+  message that lacks one at conversation completion. The `done` SSE event
+  also stamps `_ts` on the last assistant message immediately. Timestamps
+  were already rendered in the UI (Sprint 14, hover-to-reveal) but most
+  messages had no timestamp field, so nothing ever showed.
+
+- **`/usage` slash command.** Instant toggle for token usage display.
+  Shows a toast, persists to server, updates the Settings checkbox if open,
+  re-renders immediately.
+
+### Bug Fixes
+
+- **XSS via inline onclick + esc().** Skill names and file paths embedded in
+  `onclick` HTML attributes used `esc()` for encoding. `esc()` converts `'`
+  to `&#39;` (HTML-safe) but browsers decode it back before executing JS,
+  allowing skill names with apostrophes to break out of string literals.
+  Fixed by switching to `data-*` attributes + `addEventListener`.
+
+- **rglob wildcard injection.** The `name` query param for
+  `/api/skills/content?file=` was passed directly to `SKILLS_DIR.rglob()`,
+  which accepts glob patterns. `name=*` would match an arbitrary directory
+  and use it as the trust base for path traversal checking.
+  Fixed by rejecting names containing `* ? [ ]` metacharacters with 400.
+
+- **`_fmtTokens(null)` returned "null".** `String(null)` = `"null"` would
+  appear in the usage badge for sessions missing fields. Fixed with a
+  `!n || n < 0` guard returning `'0'`.
+
+- **Usage badge on wrong row.** Badge used `:last-child` which could target
+  a user message row. Fixed by adding `data-role` to message rows and
+  scanning backwards for the last `assistant` row.
+
+- **Tool name resolution.** Tool call entries in session JSON sometimes
+  stored the literal string `"tool"` as the name when the call ID couldn't
+  be resolved. Fixed: defaults to empty string and skips unresolvable entries.
+
+- **Inline import inside loop.** `import json as _j2` inside the done-handler
+  loop in `streaming.py` moved to module-level.
+
+### Session Model
+
+- Added `input_tokens`, `output_tokens`, `estimated_cost` fields to Session
+  (defaults: 0, 0, None). Included in `compact()`, session JSON, and all
+  API responses. Backward-compatible via `**kwargs`.
+
+- Added `args` capture to `tool_calls` session JSON entries (truncated
+  snapshot of tool inputs, up to 6 keys / 120 chars each).
+
+### Settings
+
+- New `show_token_usage` boolean setting (default: `false`). Stored in
+  `settings.json`, loaded on boot alongside `send_key`.
+
+### Tests
+
+- Renamed `test_sprint24.py` → `test_sprint23.py`.
+- Strengthened session usage assertions (explicit field presence checks).
+- Added: path traversal rejection test, wildcard name rejection test,
+  cron create with skills array test.
+- Total: 424 tests (up from 415).
+
+---
+
+## [v0.28.1] CI Pipeline + Multi-Arch Docker Builds
+*April 3, 2026 | 426 tests*
+
+### Features
+- **GitHub Actions CI.** New workflow triggers on tag push (`v*`). Builds
+  multi-arch Docker images (linux/amd64 + linux/arm64), pushes to
+  `ghcr.io/nesquena/hermes-webui`, and creates a GitHub Release with
+  auto-generated release notes. Uses GHA layer caching for fast rebuilds.
+- **Pre-built container images.** Users can now `docker pull ghcr.io/nesquena/hermes-webui:latest`
+  instead of building locally.
+
+---
+
+## [v0.27] Profile Creation Fallback for Docker (Issue #44)
+*April 3, 2026 | 426 tests*
+
+### Bug Fixes
+- **Profile creation works without hermes-agent.** In Docker containers where
+  `hermes_cli` is not importable, profile creation now falls back to a local
+  implementation that creates the directory structure and optionally clones
+  config files. Previously returned `RuntimeError` with "hermes-agent required".
+- **Name validation uses `fullmatch()`.** Prevents trailing-newline bypass of
+  the `$` anchor in `re.match()`. Not reachable from the web UI (name is
+  stripped), but fixed for defense-in-depth.
+- **`clone_from` validated in `create_profile_api()`.** Defense-in-depth:
+  prevents path traversal if called by a non-HTTP client.
+- **Fallback return uses full 9-key schema.** Previously returned only 2 keys
+  (`name`, `path`), inconsistent with the normal response shape.
+- **Atomic directory creation.** `mkdir(exist_ok=False)` prevents TOCTOU race
+  on concurrent profile creates.
+
+### Architecture
+- `api/profiles.py`: `_validate_profile_name()`, `_create_profile_fallback()`,
+  `_PROFILE_ID_RE`, `_PROFILE_DIRS`, `_CLONE_CONFIG_FILES` constants matching
+  upstream `hermes_cli.profiles`.
+- `docker-compose.yml`: Removed `:ro` from `~/.hermes` mount (required for
+  profile writes). Localhost-only binding preserved.
+
+---
+
+## [v0.26] Profile System Polish -- 10 Post-Sprint-23 Fixes
+*April 3, 2026 | 426 tests*
+
+### Bug Fixes
+- **Profile switch base dir bug.** When `HERMES_HOME` was mutated to a
+  `profiles/` subdir at startup, `switch_profile()` doubled the path
+  (e.g. `~/.hermes/profiles/X/profiles/X`). New `_resolve_base_hermes_home()`
+  detects profile subdirs and walks up to the actual base.
+- **Cross-provider model routing.** Picking a model from a different provider
+  than the config's default now routes through OpenRouter instead of trying
+  a direct API call to a provider whose key may not exist.
+- **Legacy sessions missing profile tag.** `all_sessions()` now backfills
+  `profile='default'` for pre-Sprint-22 sessions so the profile filter works.
+- **Workspace list cleanup.** Stale paths, test artifacts, and cross-profile
+  entries are now cleaned on load. Legacy global workspace file migrated
+  once for the default profile.
+- **API error messages.** `api()` helper now parses JSON error bodies and
+  surfaces the human-readable message instead of raw JSON.
+- **Workspace dropdown moved to sidebar.** The workspace picker now opens
+  upward from the sidebar bottom instead of clipping behind the topbar.
+
+### Features
+- **Rate limit error display.** Rate limit errors (429) now show a distinct
+  card with a rate limit icon and hint, instead of the generic error message.
+- **SSE `apperror`/`warning` events.** Server can send typed error events
+  that the frontend handles with appropriate UX (rate limit card, fallback
+  notice, etc.).
+- **Smart model resolver.** `_findModelInDropdown()` handles name mismatches
+  between config model IDs and dropdown values (e.g. `claude-sonnet-4-6` vs
+  `anthropic/claude-sonnet-4.6`).
+- **Profile switch starts new session.** When the current session has messages,
+  switching profiles automatically starts a fresh session to prevent
+  cross-profile tagging.
+- **Per-profile toolsets.** Agent now reads `platform_toolsets.cli` from the
+  active profile's config at call time, not the boot-time snapshot.
+- **Per-profile fallback model.** `fallback_model` config is read from the
+  active profile and passed to AIAgent.
+
+### Architecture
+- `api/profiles.py`: `_resolve_base_hermes_home()` replaces naive env var read.
+- `api/workspace.py`: `_clean_workspace_list()`, `_migrate_global_workspaces()`.
+- `api/streaming.py`: Per-profile toolsets and fallback model at call time.
+- `api/models.py`: `all_sessions()` backfills `profile='default'`.
+- `static/ui.js`: `_findModelInDropdown()`, `_applyModelToDropdown()`.
+- `static/messages.js`: `apperror` and `warning` SSE event handlers.
+
+---
+
+## [v0.25] Sprint 23 -- Profile/Workspace/Model Coherence
+*April 3, 2026 | 423 tests*
+
+### Features
+- **Profile-local workspace storage.** Each named profile now stores its own
+  `workspaces.json` and `last_workspace.txt` under `{profile_home}/webui_state/`.
+  Default profile continues using the global STATE_DIR for backward compat.
+- **Profile switch returns defaults.** `POST /api/profile/switch` response now
+  includes `default_model` and `default_workspace` from the new profile's
+  config.yaml, enabling one-round-trip state sync.
+- **Session profile filter.** Session sidebar filters to the active profile by
+  default. "Show N from other profiles" toggle reveals sessions from all
+  profiles, modeled on the existing archived toggle. Resets on profile switch.
+
+### Bug Fixes
+- **Model picker ignores profile on switch.** `switchToProfile()` now clears
+  the `hermes-webui-model` localStorage key so the profile's default model
+  applies instead of a stale preference from another profile.
+- **Workspace list was global.** Switching profiles no longer shows the wrong
+  profile's workspaces.
+- **`DEFAULT_WORKSPACE` was a boot-time singleton.** Now resolved dynamically
+  through `_profile_default_workspace()`.
+- **Session list showed all profiles.** Now filtered to active profile.
+- **`switchToProfile()` didn't refresh workspaces or sessions.** Now refreshes
+  workspace list, session list, and resets profile filter on switch.
+
+### Architecture
+- `api/workspace.py` rewritten with profile-aware path resolution.
+- `api/profiles.py`: `switch_profile()` returns `default_model` and
+  `default_workspace`.
+- `static/sessions.js`: Profile filter with toggle UI.
+- `static/panels.js`: Full cascade refresh on profile switch.
+- 8 new tests in `test_sprint23.py`.
+
+---
+
+## [v0.24] Sprint 22 -- Multi-Profile Support (Issue #28)
+*April 3, 2026 | 415 tests*
+
+### Features
+- **Profile picker (topbar).** Purple-accented chip with SVG user icon. Click
+  to open dropdown listing all profiles with gateway status dots (green =
+  running), model info, and skill count. Click any profile to switch; "Manage
+  profiles" link opens the sidebar panel.
+- **Profiles management panel.** New sidebar tab with full CRUD UI. Profile
+  cards show name, model/provider, skill count, API key status, and gateway
+  status badge. "Use" button switches profile, delete button removes non-default
+  profiles (with confirmation).
+- **Profile creation.** "+ New profile" form with name validation (`[a-z0-9_-]`),
+  optional "clone config from active" checkbox. Wraps the CLI's
+  `hermes_cli.profiles.create_profile()`.
+- **Profile deletion.** Confirm dialog. Auto-switches to default if deleting
+  the active profile. Blocked while agent is running.
+- **Seamless profile switching.** No server restart. Profile switch updates
+  `HERMES_HOME`, patches module-level caches in hermes-agent's `skills_tool`
+  and `cron/jobs`, reloads `.env` API keys and `config.yaml`, refreshes the
+  model dropdown, skills, memory, and cron panels.
+- **Per-session profile tracking.** `profile` field on Session records which
+  profile was active at creation. Backward-compatible (`null` for old sessions).
+
+### Bug Fixes
+- **Hardcoded `~/.hermes` paths.** Memory read/write and model discovery used
+  hardcoded paths. Now resolved through `get_active_hermes_home()`.
+- **Module-level path caching.** hermes-agent modules snapshot `HERMES_HOME`
+  at import time. Profile switch now monkey-patches `SKILLS_DIR`, `CRON_DIR`,
+  `JOBS_FILE`, `OUTPUT_DIR` so they track the active profile.
+
+### Architecture
+- New `api/profiles.py`: profile state management wrapping `hermes_cli.profiles`.
+  Thread-safe (`_profile_lock`). Lazy imports avoid circular deps.
+- `api/config.py`: module-level `cfg` replaced with reloadable `get_config()`
+  / `reload_config()`. Dynamic `_get_config_path()` resolves through profile.
+- `api/streaming.py`: `HERMES_HOME` added to env save/restore block.
+- Profile switch blocked while agent streams are active.
+- 5 new API endpoints: `GET /api/profiles`, `GET /api/profile/active`,
+  `POST /api/profile/switch`, `POST /api/profile/create`,
+  `POST /api/profile/delete`.
+- Zero modifications to hermes-agent code.
+
+---
+
+## [v0.23] Sprint 21 -- Mobile Responsive + Docker
+*April 3, 2026 | 415 tests*
+
+### Features
+- **Mobile responsive layout (Issue #21).** Full mobile experience with
+  hamburger sidebar (slide-in overlay), bottom navigation bar (5-tab iOS
+  pattern), and files slide-over panel. Touch targets minimum 44px. Composer
+  positioned above bottom nav. Session clicks auto-close sidebar. Desktop
+  layout completely unchanged — all mobile elements hidden via `@media`.
+- **Docker support (Issue #7).** Dockerfile (`python:3.12-slim`), docker-compose.yml
+  with named volume for state persistence, optional `~/.hermes` mount for
+  agent features. Binds to `127.0.0.1` by default for security.
+
+### Bug Fixes (from review)
+- **CSS cascade broke mobile slide-in.** `position:relative` rules after the
+  media query overrode `position:fixed` on mobile. Wrapped in `@media(min-width:641px)`.
+- **mobileSwitchPanel() always reopened sidebar.** Chat tab now closes sidebar
+  instead of reopening it over the main chat area.
+- **Dockerfile missing pip install.** Added `pip install -r requirements.txt`.
+- **No .dockerignore.** Added exclusions for `.git`, `tests/`, `.env*`.
+- **docker-compose tilde expansion.** Changed `~/.hermes` default to
+  `${HOME}/.hermes` (Docker Compose doesn't shell-expand `~`).
+
+### Architecture
+- Mobile navigation functions in `boot.js`: `toggleMobileSidebar()`,
+  `closeMobileSidebar()`, `toggleMobileFiles()`, `mobileSwitchPanel()`.
+- `sessions.js`: `closeMobileSidebar()` called after session click.
+- 69 new CSS lines in `@media(max-width:640px)` block.
+- New files: `Dockerfile`, `docker-compose.yml`, `.dockerignore`.
+
+---
+
+## [v0.22] Sprint 20 -- Voice Input + Send Button Polish
+*April 3, 2026 | 415 tests*
+
+### Features
+- **Voice input via Web Speech API.** Microphone button in the composer.
+  Tap to start recording, tap again (or send) to stop. Live interim
+  transcription appears in the textarea. Auto-stops after ~2s of silence.
+  Final text stays editable before sending. Appends to existing textarea
+  content rather than replacing it. Button hidden when browser doesn't
+  support Web Speech API. No API keys, no external libraries, no server
+  changes. Works in Chrome, Edge, Safari (partial). Firefox unsupported
+  (button stays hidden).
+- **Send button polish.** Send button redesigned as a 34px icon-only circle
+  with upward arrow SVG. Hidden by default — appears with pop-in spring
+  animation when textarea has content or files are attached. Disappears
+  on send or when content is cleared. Hidden while agent is responding.
+  Blue fill (#7cb9ff) with glow, scale hover/active for tactile feedback.
+
+### Architecture
+- Voice input IIFE in `boot.js`: SpeechRecognition lifecycle with
+  `continuous=false`, `interimResults=true`, error handling via `showToast()`.
+- `_prefix` variable snapshots existing textarea content on recording start
+  so dictation appends rather than overwrites.
+- `btnSend.onclick` stops active recognition before sending (send guard).
+- CSS: `.mic-btn`, `.mic-btn.recording` (red pulse), `.mic-status`,
+  `.mic-dot`, `@keyframes mic-pulse`.
+- `updateSendBtn()` in `ui.js` tracks textarea content, pending files,
+  and busy state. Hooked into `setBusy()`, `renderTray()`, `autoResize()`,
+  and input event listener.
+- CSS: `.send-btn` redesigned (circle, glow), `.send-btn.visible` +
+  `@keyframes send-pop-in` (spring animation).
+
+### Tests
+- 52 new tests in `test_sprint20.py`: voice input HTML, CSS, JS, append
+  behaviour, error handling, regressions.
+- 33 new tests in `test_sprint20b.py`: send button HTML, CSS, JS,
+  animation, visibility logic, regressions. Total: **415 tests**.
+
+---
+
+## [v0.21] Sprint 19 -- Auth + Security Hardening
+*April 3, 2026 | 328 tests*
+
+### Features
+- **Password authentication (Issue #23).** Optional password auth, off by default.
+  Enable via `HERMES_WEBUI_PASSWORD` env var or Settings panel. Password-only
+  (single-user app). Signed HMAC HTTP-only cookie with 24h TTL. Minimal dark-themed
+  login page at `/login`. API calls without auth return 401; page loads redirect.
+  New `api/auth.py` module with hashing, verification, session management.
+- **Security headers.** All responses now include `X-Content-Type-Options: nosniff`,
+  `X-Frame-Options: DENY`, `Referrer-Policy: same-origin`.
+- **POST body size limit.** Non-upload POST bodies capped at 20MB via `read_body()`.
+- **Settings panel additions.** "Access Password" field and "Sign Out" button
+  (only visible when auth is active).
+
+### Architecture
+- New `api/auth.py`: password hashing (SHA-256 + STATE_DIR salt), signed cookies,
+  auth middleware, public path allowlist.
+- Auth check in `server.py` do_GET/do_POST before routing.
+- `password_hash` added to `_SETTINGS_DEFAULTS`.
+
+### Tests
+- 10 new tests in `test_sprint19.py`: auth status, login flow, security headers,
+  cache-control, settings password field, request size limit. Total: **328 tests (328 passing)**.
+
+---
+
+## [v0.20] Sprint 18 -- File Preview Auto-Close + Thinking Display + Workspace Tree
+*April 3, 2026 | 318 tests*
+
+### Features
+- **File preview auto-close on directory navigation.** When viewing a file in
+  the right panel and navigating directories (breadcrumbs, up button, folder
+  clicks), the preview now automatically closes instead of showing stale
+  content. `clearPreview()` extracted as named function and called from
+  `loadDir()`. Unsaved preview edits prompt for confirmation before discarding.
+- **Thinking/reasoning display.** Assistant messages with structured content
+  arrays containing `type:'thinking'` or `type:'reasoning'` blocks (Claude
+  extended thinking, o3 reasoning) now render as collapsible gold-themed cards
+  above the response text. Collapsed by default. Click the header to expand and
+  see the model's reasoning process. Uses `esc()` on all content for XSS safety.
+- **Workspace tree view (Issue #22).** Directories expand/collapse in-place
+  with toggle arrows. Single-click toggles a directory open/closed. Double-click
+  navigates into it (breadcrumb view). Subdirectory contents fetched lazily from
+  the API and cached in `S._dirCache`. Nesting depth shown via indentation.
+  Empty directories show "(empty)" placeholder. Breadcrumb navigation still
+  works alongside the tree view.
+
+### Bug Fixes
+- **Stale tree cache on session switch.** `S._dirCache` and `S._expandedDirs`
+  are now cleared when navigating to the root directory, preventing session B
+  from showing session A's cached file listings.
+- **clearPreview() discards unsaved edits.** Navigation now checks
+  `_previewDirty` and prompts before discarding unsaved preview changes.
+
+### Architecture
+- `clearPreview()` extracted from inline handler to named function in `boot.js`.
+- Thinking card styles added to `style.css` (gold-themed, collapsible).
+- Tree toggle and empty-directory styles added to `style.css`.
+
+---
+
+## [v0.19] Sprint 17 -- Workspace Polish + Slash Commands + Settings
+*April 3, 2026 | 318 tests*
+
+### Features
+- **Workspace breadcrumb navigation.** Clicking into subdirectories now shows a
+  breadcrumb path bar (e.g. `~ / src / components`) with clickable segments to
+  navigate back. An "up" button appears in the panel header when inside a
+  subdirectory. File operations (rename, delete, new file/folder) stay in the
+  current directory instead of jumping back to root. Foundation for Issue #22
+  (tree view).
+- **Slash commands.** Type `/` in the composer to see an autocomplete dropdown
+  of built-in commands. New `commands.js` module with command registry. Built-in
+  commands: `/help`, `/clear`, `/model <name>`, `/workspace <name>`, `/new`.
+  Arrow keys navigate, Tab/Enter select, Escape closes. Unrecognized commands
+  pass through to the agent normally.
+- **Send key setting (Issue #26).** New setting in Settings panel to choose
+  between Enter (default) and Ctrl/Cmd+Enter as the send key. Persisted to
+  `settings.json` via the existing settings API. Setting loads on boot.
+  Server-side validation ensures only valid values (`enter`, `ctrl+enter`).
+
+### Architecture
+- New `static/commands.js` module (7th JS module): command registry, parser,
+  autocomplete dropdown, and built-in command handlers.
+- `send_key` added to `_SETTINGS_DEFAULTS` in `api/config.py` with enum validation
+  (`_SETTINGS_ENUM_VALUES` rejects unknown values server-side).
+- `S.currentDir` state tracking added to `ui.js` for workspace navigation.
+
+### Tests
+- 6 new tests in `test_sprint17.py`: send_key default, round-trip save with
+  cleanup, invalid value rejection, unknown key ignored, commands.js served,
+  workspace root listing. Total: **318 passed**.
+
+---
+
+## [v0.18.1] Safe HTML Rendering + Sprint 16 Tests
+*April 2, 2026 | 289 tests*
+
+### Features
+- **Safe HTML rendering in AI responses.** AI models sometimes emit HTML tags
+  (`<strong>`, `<em>`, `<code>`, `<br>`) in their responses. Previously these
+  showed as literal escaped text. A new pre-pass in `renderMd()` converts safe
+  HTML tags to markdown equivalents before the pipeline runs. Code blocks and
+  backtick spans are stashed first so their content is never touched.
+- **`inlineMd()` helper.** New function for processing inline formatting inside
+  list items, blockquotes, and headings. The old code called `esc()` directly,
+  which escaped tags that had already been converted by the pre-pass.
+- **Safety net.** After the full pipeline, any HTML tags not in the output
+  allowlist (`SAFE_TAGS`) are escaped via `esc()`. XSS fully blocked -- 7
+  attack vectors tested.
+- **Active session gold style.** Active session uses gold/amber (`#e8a030`)
+  instead of blue, matching the logo gradient. Project border-left skipped
+  when active (gold always wins).
+
+### Tests
+- **74 new tests** in `test_sprint16.py`: static analysis (6), behavioral (10),
+  exact regression (1), XSS security (7), edge cases (51). Total: 289 passed.
+
+---
+
+## [v0.18] Sprint 16 -- Session Sidebar Visual Polish
+*April 2, 2026 | 237 tests*
+
+### Features
+- **SVG action icons.** Replaced all emoji HTML entities (star, folder, box,
+  duplicate, trash) with monochrome SVG line icons that inherit `currentColor`.
+  Consistent rendering across macOS, Linux, and Windows. Defined in a top-level
+  `ICONS` constant in `sessions.js`.
+- **Action buttons overlay.** All session action buttons (pin, move, archive,
+  duplicate, trash) wrapped in a `.session-actions` container with
+  `position:absolute`. Titles now use full available width instead of being
+  truncated by invisible buttons. Actions appear on hover with a gradient fade
+  from the right edge. Overlay auto-hides during inline rename via
+  `:has(.session-title-input)`.
+- **Pin indicator.** Small gold filled-star icon rendered inline before the
+  title only when pinned. Unpinned sessions get full title width with zero
+  space reservation.
+- **Project border indicator.** Sessions assigned to a project show a colored
+  left border matching the project color, replacing the old always-visible
+  blue folder button.
+
+### Bug Fixes
+- **Session title truncation.** Action icons reserved ~30px of space even when
+  invisible, truncating titles. Fixed by overlay container approach.
+- **Folder button felt sticky.** Replaced `.has-project` persistent blue button
+  with colored left border. Folder button now only appears in hover overlay.
+
+---
+
+## [v0.17.3] Bug Fixes
+*April 2, 2026*
+
+### Bug Fixes
+- **NameError crash in model discovery.** `logger.debug()` was called in the
+  custom endpoint `except` block in `config.py`, but `logger` was never
+  imported. Every failed custom endpoint fetch crashed with `NameError`,
+  returning HTTP 500 for `/api/models`. Replaced with silent `pass` since
+  unreachable endpoints are expected. (PR #24)
+- **Project picker clipping and width.** Picker was clipped by
+  `overflow:hidden` on ancestor elements. Width calculation improved with
+  dynamic sizing (min 160px, max 220px). Event listener `close` handler
+  moved after DOM append to fix reference-before-definition. Reordered
+  `picker.remove()` before `removeEventListener` for correct cleanup. (PR #25)
+
+---
+
+## [v0.17.2] Model Update
+*April 2, 2026*
+
+### Enhancements
+- **GLM-5.1 added to Z.AI model list.** New model available in the dropdown
+  for Z.AI provider users. (Fixes #17)
+
+---
+
+## [v0.17.1] Security + Bug Fixes
+*April 2, 2026 | 237 tests*
+
+### Security
+- **Path traversal in static file server.** `_serve_static()` now sandboxes
+  resolved paths inside `static/` via `.relative_to()`. Previously
+  `GET /static/../../.hermes/config.yaml` could expose API keys.
+- **XSS in markdown renderer.** All captured groups in bold, italic, headings,
+  blockquotes, list items, table cells, and link labels now run through `esc()`
+  before `innerHTML` insertion.
+- **Skill category path traversal.** Category param validated to reject `/`
+  and `..` to prevent writing outside `~/.hermes/skills/`.
+- **Debug endpoint locked to localhost.** `/api/approval/inject_test` returns
+  404 to any non-loopback client.
+- **CDN resources pinned with SRI hashes.** PrismJS and Mermaid tags now have
+  `integrity` + `crossorigin` attributes. Mermaid pinned to `@10.9.3`.
+- **Project color CSS injection.** Color field validated against
+  `^#[0-9a-fA-F]{3,8}$` to prevent `style.background` injection.
+- **Project name length limit.** Capped at 128 chars, empty-after-strip rejected.
+
+### Bug Fixes
+- **OpenRouter model routing regression.** `resolve_model_provider()` was
+  incorrectly stripping provider prefixes from OpenRouter model IDs (e.g.
+  `openai/gpt-5.4-mini` became `gpt-5.4-mini` with provider `openai`),
+  causing AIAgent to look for OPENAI_API_KEY and crash. Fix: only strip
+  prefix when `config.provider` explicitly matches that direct-API provider.
+- **Project picker invisible.** Dropdown was clipped by `.session-item`
+  `overflow:hidden`. Now appended to `document.body` with `position:fixed`.
+- **Project picker stretched full width.** Added `max-width:220px;
+  width:max-content` to constrain the fixed-positioned picker.
+- **No way to create project from picker.** Added "+ New project" item at
+  the bottom of the picker dropdown.
+- **Folder button undiscoverable.** Now shows persistently (blue, 60%
+  opacity) when session belongs to a project.
+- **Picker event listener leak.** `removeEventListener` added to all picker
+  item onclick handlers.
+- **Redundant sys.path.insert calls removed.** Two cron handler imports no
+  longer prepend the agent dir (already on sys.path via config.py).
+
+---
+
+## [v0.17] Sprint 15 -- Session Projects + Code Copy + Tool Card Toggle
+*April 1, 2026 | 237 tests*
+
+### Features
+- **Session projects.** Named groups for organizing sessions. A project filter
+  bar (subtle chips) sits between the search input and the session list. Each
+  project has a name and color. Click a chip to filter; "All" shows everything.
+  Create inline (+), rename (double-click), delete (right-click). Assign sessions
+  via folder icon button with dropdown picker. Projects stored in `projects.json`.
+  Session model gains `project_id` field. 5 new API endpoints.
+- **Code block copy button.** Every code block gets a "Copy" button in the
+  language header bar (or top-right for plain blocks). Click copies to clipboard,
+  shows "Copied!" for 1.5s.
+- **Tool card expand/collapse.** When a message has 2+ tool cards, "Expand all /
+  Collapse all" toggle appears above the card group.
+
+---
+
+## [v0.16.2] Model List Updates + base_url Passthrough
+*April 1, 2026 | 247 tests*
+
+### Bug Fixes
+- **MiniMax model list updated.** Replaced stale ABAB 6.5 models with current
+  MiniMax-M2.7, M2.7-highspeed, M2.5, M2.5-highspeed, M2.1 lineup matching
+  hermes-agent upstream. (Fixes #6)
+- **Z.AI/GLM model list updated.** Replaced GLM-4 series with current GLM-5,
+  GLM-5 Turbo, GLM-4.7, GLM-4.5, GLM-4.5 Flash lineup.
+- **base_url passthrough to AIAgent.** `resolve_model_provider()` now reads
+  `base_url` from config.yaml and passes it to AIAgent, so providers with
+  custom endpoints (MiniMax, Z.AI, local LLMs) route to the correct API.
+
+---
+
+## [v0.16.1] Community Fixes -- Mobile + Auth + Provider Routing
+*April 1, 2026 | 247 tests*
+
+Community contributions from @deboste, reviewed and refined.
+
+### Bug Fixes
+- **Mobile responsive layout.** Comprehensive `@media(max-width:640px)` rules
+  for topbar, messages, composer, tool cards, approval cards, and settings modal.
+  Uses `100dvh` with `100vh` fallback to fix composer cutoff on mobile browsers.
+  Textarea `font-size:16px` prevents iOS/Android auto-zoom on focus.
+- **Reverse proxy basic auth support.** All `fetch()` and `EventSource` URLs now
+  constructed via `new URL(path, location.origin)` to strip embedded credentials
+  per Fetch spec. `credentials:'include'` on fetch, `withCredentials:true` on
+  EventSource ensure auth headers are forwarded through reverse proxies.
+- **Model provider routing.** New `resolve_model_provider()` helper in
+  `api/config.py` strips provider prefix from dropdown model IDs (e.g.
+  `anthropic/claude-sonnet-4.6` → `claude-sonnet-4.6`) and passes the correct
+  `provider` to AIAgent. Handles cross-provider selection by matching against
+  known direct-API providers.
 
 ---
 
@@ -405,4 +1348,7 @@ Three-panel layout: sessions sidebar, chat area, workspace panel.
 
 ---
 
-*Last updated: Sprint 14, March 31, 2026 | Tests: 224/224*
+*Last updated: v0.36, April 5, 2026 | Tests: 433*
+
+### Markdown sweep
+- ROADMAP.md, TESTING.md, SPRINTS.md, README.md, and THEMES.md refreshed to match v0.36 and 433 tests.

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.12-slim
+
+LABEL maintainer="nesquena"
+LABEL description="Hermes Web UI — browser interface for Hermes Agent"
+
+WORKDIR /app
+
+# Copy source
+COPY . /app
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Default to binding all interfaces (required for container networking)
+ENV HERMES_WEBUI_HOST=0.0.0.0
+ENV HERMES_WEBUI_PORT=8787
+
+# State directory (mount as volume for persistence)
+ENV HERMES_WEBUI_STATE_DIR=/data
+
+EXPOSE 8787
+
+CMD ["python", "server.py"]

HERMES.md

@@ -0,0 +1,375 @@
+# Why Hermes
+
+Hermes is a persistent, autonomous AI agent that lives on your server. It remembers everything,
+schedules work while you sleep, and gets more capable the longer it runs. This document explains
+the mental model, why that matters, and how Hermes compares to every major AI tool available today.
+
+---
+
+## The Core Idea: Assistants Forget. Agents Don't.
+
+Every time you open Claude Code, Codex, or a chat window, the tool starts from zero. It does not
+know who you are, what you worked on yesterday, how your repo is structured, or what bugs you
+already fixed. You re-explain yourself every single session. The tool is powerful in the moment
+and useless the next day.
+
+Hermes fills that gap. It runs on your server, retains context across every session, and acts
+on your behalf whether or not you are at a keyboard.
+
+```
+Assistant model:  You -> [Tool] -> Answer -> Done
+                  (tool forgets everything when the window closes)
+
+Agent model:      You <-> [Hermes] <-> (memory, skills, schedule, tools)
+                  (persistent, learns your stack, acts on your behalf, runs while you're offline)
+```
+
+---
+
+## The Three Pillars
+
+### 1. Memory That Compounds
+
+Hermes has layered memory that survives every session, every reboot, every model swap:
+
+- **User profile** -- who you are, your preferences, your communication style, things you've
+  corrected Hermes on
+- **Agent memory** -- facts about your environment, your toolchain, your project conventions
+- **Skills** -- reusable procedures Hermes discovers and saves; it never has to relearn how to
+  deploy your app, run your tests, or review a PR
+- **Session history** -- every past conversation is searchable; Hermes can recall what you
+  worked on last Tuesday
+
+When you correct Hermes, it remembers. When it solves a tricky problem, it saves the approach.
+When it learns your stack, that knowledge carries into every future session.
+
+### 2. Autonomous Scheduling
+
+Hermes can run jobs without you present -- every hour, every morning, on any cron schedule.
+It fires up a fresh session, runs the task, and delivers the result to wherever you want it:
+Telegram, Discord, Slack, Signal, WhatsApp, SMS, email, and more.
+
+Things Hermes can do while you sleep:
+
+- Review new pull requests on your GitHub repo and post a full verdict comment
+- Send you a morning briefing of news, markets, or anything else you care about
+- Run your test suite and alert you if something breaks
+- Watch a competitor's blog for new posts and summarize them
+- Monitor a datasource and notify you when a threshold is crossed
+
+### 3. Reach It From Anywhere
+
+Hermes runs on your server and is reachable from every surface: terminal over SSH, the web UI
+(this project), and messaging apps including Telegram, Discord, Slack, WhatsApp, Signal, and
+Matrix. Start a task from your phone, check it from the browser on your laptop, continue it in
+a terminal on a remote server. The same agent, memory, and history follow you everywhere.
+
+---
+
+## A Framework for AI Tools
+
+There are four distinct categories of AI tool. Understanding the category tells you what a tool
+can and cannot do.
+
+### Category 1: Chat Assistants
+*Claude.ai, ChatGPT, Gemini*
+
+You open a window, ask something, get an answer. No persistent memory beyond the conversation,
+no ability to run code or touch files, no way to act on your behalf. Excellent for Q&A,
+drafting, and brainstorming. You re-explain your context every session.
+
+### Category 2: IDE Integrations
+*GitHub Copilot, Cursor, Windsurf, Zed AI*
+
+Deep inside your editor. Autocomplete, inline diffs, refactors -- all excellent. Windsurf was
+earliest with workspace-scoped memory (Cascade Memories); Copilot has been shipping repo-level
+memory since late 2025 and is catching up. Cursor has no native memory as of early 2026. None
+have scheduling or messaging access. Tied to one machine and one editor.
+
+### Category 3: Agentic CLI Tools
+*Claude Code, Codex CLI, OpenCode, Aider*
+
+The current frontier for most developers. Can use real tools -- run shell commands, read and
+write files, search the web, call APIs. Great for deep, multi-step tasks in a single terminal
+session. All are adding memory and scheduling features to varying degrees (see comparisons below),
+but the core model is still session-scoped: you invoke it, it works, it stops.
+
+### Category 4: Persistent Autonomous Agents
+*Hermes, OpenClaw (as of early 2026)*
+
+All the tool use of Category 3, plus memory that accumulates across sessions, plus always-on
+scheduling, plus multi-modal access from any device or messaging app. Gets more useful over time
+rather than resetting to zero. Hermes and OpenClaw are the two primary open-source, self-hosted
+tools in this category. OpenClaw is a gateway-centric automation platform; Hermes is a
+self-improving agent that writes and reuses its own procedures from experience.
+
+---
+
+## How Hermes Compares
+
+### vs. OpenClaw
+
+OpenClaw is the most direct comparison to Hermes and the question most people ask first.
+Both are open-source, self-hosted, always-on agents with persistent memory, cron scheduling,
+and messaging app integration. If you're evaluating Hermes, you should evaluate OpenClaw too.
+
+OpenClaw (MIT, ~347k GitHub stars) is built around a **Gateway** control plane written in
+Node.js/TypeScript. It excels at broad personal automation: native Chrome/Chromium control for
+browser automation, the widest messaging platform support in the space (WhatsApp, Telegram,
+Signal, iMessage, LINE, WeChat, Slack, Discord, Teams, Matrix, and more), voice wake words,
+and a ClawHub skill marketplace where users share pre-built automations. The community is large
+and the ecosystem is growing fast.
+
+Hermes takes a different approach. It is built in Python and centers on a **self-improving
+agent loop** rather than a gateway control plane. The core difference is in how skills work:
+OpenClaw skills are primarily human-authored plugins installed from a marketplace; Hermes
+**writes and saves its own skills automatically** as part of every session. When Hermes solves
+a problem a new way, it saves the procedure and reuses it going forward without any user effort.
+
+Beyond the skills architecture, there are two other practical differences worth knowing:
+
+**Stability.** OpenClaw's community forums and GitHub issues document a recurring pattern of
+update-breaking regressions -- for example, Telegram integration was broken across multiple
+releases in early 2026. The unofficial WhatsApp Web protocol OpenClaw uses is known to
+disconnect and requires periodic re-pairing (this is documented in OpenClaw's own FAQ).
+Hermes has had no equivalent release breakages.
+
+**Security.** ClawHub's open publishing model has been exploited repeatedly. A community audit
+identified over a thousand malicious skills in the marketplace including prompt injections and
+tool-poisoning payloads; the community-maintained awesome-openclaw-skills list tracks confirmed
+removals and flags known bad actors. Hermes has no third-party marketplace and a correspondingly
+smaller attack surface.
+
+**OpenClaw's genuine strengths** are worth stating plainly: it has broader messaging coverage
+(iMessage, LINE, WeChat, Teams -- platforms Hermes does not support), native browser and
+computer control via Chrome CDP, voice wake words on macOS and iOS, a larger community, and
+more third-party integrations than Hermes. If those capabilities matter most to you, OpenClaw
+is worth a serious look.
+
+Where Hermes is the better fit: you want an agent that self-improves from experience without
+manual plugin authoring, you work in Python and want access to the ML/data science ecosystem,
+you want a stable deployment that does not break between updates, or you want a full web chat
+UI rather than a monitoring dashboard.
+
+| | OpenClaw | Hermes |
+|---|---|---|
+| Persistent memory | Yes | Yes |
+| Scheduled jobs (cron) | Yes | Yes |
+| Messaging app access | Yes (15+ platforms, incl. iMessage/WeChat) | Yes (10+ platforms) |
+| Web UI | Gateway dashboard (monitoring only) | Full three-panel chat UI |
+| Self-hosted | Yes | Yes |
+| Open source | Yes (MIT) | Yes |
+| Self-improving skills | Partial (AI can generate skills; not the default loop) | Yes (automatic, first-class) |
+| Browser / computer control | Yes (native Chrome CDP) | Via shell / tools |
+| Voice wake words | Yes (macOS/iOS) | No |
+| Python / ML ecosystem | No (Node.js) | Yes |
+| Orchestrates Claude Code / Codex | No | Yes |
+| Multi-profile support | Via binding-rule routing | Yes (first-class named profiles) |
+| Provider-agnostic | Yes | Yes |
+| Update reliability | Moderate (documented regressions) | High |
+
+### vs. Claude Code (Anthropic)
+
+Claude Code is Anthropic's official agentic CLI and one of the best tools in Category 3.
+In a single focused session it is capable -- deep code understanding, shell access, file
+editing, multi-step reasoning.
+
+Claude Code has been adding features rapidly and the gap is narrowing:
+
+- **Hooks system** -- 13 event types (SessionStart, PreToolUse, PostToolUse, Stop, etc.) with
+  4 handler types (shell command, HTTP endpoint, LLM prompt, sub-agent); deterministic
+  non-LLM control over the agent lifecycle
+- **Plugins / Skills** -- installable via `/plugin install`, hot-reloaded from `~/.claude/skills`,
+  with a marketplace; skills and slash commands unified as of v2.1.0
+- **Scheduling** -- `/loop` (session-scoped), cloud-managed cron via `claude.ai/code/scheduled`
+  (Anthropic infrastructure, minimum interval applies), and desktop app automations
+- **Messaging channels** -- Telegram, Discord, iMessage, and webhooks via the Channels feature
+  (research preview, v2.1.80+); deep Slack integration that triggers cloud sessions and creates PRs
+- **Claude Cowork** -- a separate product for knowledge workers; connects to 38+
+  services via MCP including Slack, Gmail, Microsoft Teams, Notion, Jira, Salesforce, and more
+- **Memory** -- CLAUDE.md and MEMORY.md for project-level context; auto-memory rolling out
+
+These are real features. The key differences that remain:
+
+- Claude Code's scheduling runs on **Anthropic's cloud** (or requires the desktop app open),
+  not a self-hosted server; cloud jobs have a minimum interval and your data leaves your hardware
+- Memory is **project-file-based** (CLAUDE.md / MEMORY.md), not a knowledge graph that
+  accumulates automatically across all your work; auto-memory is still rolling out
+- **Not provider-agnostic** -- routes through Bedrock or Vertex but always hits a Claude model;
+  you cannot switch to GPT, Gemini, or a local model
+- **Not open source** -- proprietary; the CLI ships obfuscated JavaScript
+- Messaging channels are a **research preview** requiring Bun runtime; not yet production-grade
+
+Hermes can use Claude Code as a sub-agent. For large implementation tasks, Hermes can spawn
+Claude Code to handle the heavy lifting and fold the result back into its own memory and history.
+
+| | Claude Code | Hermes |
+|---|---|---|
+| Persistent memory (automatic) | Partial (CLAUDE.md / MEMORY.md, rolling out) | Yes |
+| Skills / hooks system | Yes (Hooks + Plugin/Skills marketplace) | Yes (auto-generated from experience) |
+| Scheduled jobs (self-hosted) | No (cloud or desktop-app only) | Yes |
+| Messaging access | Partial (Telegram/Discord/iMessage via research preview; Slack native) | Yes (10+ platforms, production) |
+| Cowork connectors (Slack, Gmail, etc.) | Yes (via Claude Cowork, separate product) | Via agent tool use |
+| Web UI | Yes (claude.ai/code, Anthropic-hosted) | Yes (self-hosted) |
+| Provider-agnostic | No (Claude models only, via Bedrock/Vertex) | Yes (any provider) |
+| Self-hosted scheduling | No | Yes |
+| Open source | No | Yes |
+| Runs as sub-agent of Hermes | Yes | N/A |
+
+### vs. Codex CLI (OpenAI)
+
+Codex CLI is OpenAI's open-source agentic terminal tool (Apache 2.0, ~73k GitHub stars). It
+supports 10+ providers including Anthropic, Google, Mistral, Groq, and local models via Ollama.
+It added persistent session memory in v0.100.0 with `codex resume`. The desktop app has an
+Automations feature for scheduled local tasks.
+
+The CLI itself has no native scheduling (open feature request as of early 2026). Memory is
+session-history-based rather than a living knowledge graph. No messaging app access. A strong
+tool for single-session coding; Hermes adds the always-on layer on top.
+
+| | Codex CLI | Hermes |
+|---|---|---|
+| Persistent memory | Partial (session history + AGENTS.md) | Yes (automatic, layered) |
+| Scheduled jobs | Partial (desktop app only; CLI has none) | Yes |
+| Messaging app access | No | Yes |
+| Web UI | No | Yes (self-hosted) |
+| Provider-agnostic | Yes (10+ providers) | Yes (10+ providers) |
+| Self-hosted | Yes | Yes |
+| Open source | Yes (Apache 2.0) | Yes |
+
+### vs. OpenCode
+
+OpenCode is an open-source TUI agentic coding assistant, provider-agnostic across 75+ providers.
+It has a WebUI embedded in its binary and an official desktop app. It uses SQLite for session
+history and AGENTS.md for project context.
+
+No native scheduled jobs (a community background plugin exists), no first-party messaging
+integration (community Telegram bots exist but require manual setup), and no automatic
+cross-session semantic memory. Good for interactive terminal coding sessions.
+
+| | OpenCode | Hermes |
+|---|---|---|
+| Persistent memory | Partial (session history + AGENTS.md) | Yes (automatic, layered) |
+| Scheduled jobs | No (community plugin only) | Yes |
+| Messaging app access | No (community Telegram bot only) | Yes (first-party, 10+ platforms) |
+| Web UI | Yes (embedded + desktop app) | Yes (self-hosted) |
+| Mobile access | No | Yes |
+| Skills system | No | Yes |
+| Provider-agnostic | Yes (75+ providers) | Yes |
+| Open source | Yes | Yes |
+
+### vs. Cursor / Windsurf / Copilot
+
+Category 2 tools -- exceptional at in-editor autocomplete, inline diffs, and code review.
+Not competing for the same job as Hermes, and they work well alongside it.
+
+Windsurf was earliest with workspace-scoped memory (Cascade Memories); Copilot has been
+shipping repo-level memory since late 2025. Cursor has no native cross-session memory as of
+early 2026. None have scheduling or messaging access.
+
+| | Cursor | Windsurf | Copilot | Hermes |
+|---|---|---|---|---|
+| In-editor autocomplete | Excellent | Excellent | Excellent | No |
+| Inline diff / refactor | Yes | Yes | Yes | Via shell |
+| Cross-session memory | No | Yes (workspace) | Partial (repo, early access) | Yes |
+| Scheduled background jobs | No | No | No | Yes |
+| Messaging app / mobile | No | No | No | Yes |
+| Terminal tool use | Limited | Limited | Limited | Full |
+| Self-hosted | No | No | No | Yes |
+| Provider-agnostic | Partial | Partial | No | Yes |
+| Open source | No | No | No | Yes |
+
+### vs. Claude.ai / ChatGPT
+
+Category 1. For drafting, Q&A, and brainstorming in the moment, both are excellent.
+
+Claude.ai memory has been improving -- it now generates memory from chat history, not just
+user-curated entries. Claude.ai can also execute code and read/write files in a sandboxed
+environment via Artifacts. These are real capabilities, just not the same as direct filesystem
+or shell access on your own server.
+
+| | Claude.ai / ChatGPT | Hermes |
+|---|---|---|
+| Memory across conversations | Yes (improving; auto-generated from history) | Yes (deep, automatic) |
+| Runs shell commands | No | Yes |
+| Code execution | Sandboxed (Artifacts) | Yes (full shell) |
+| Reads / writes files | Sandboxed (Artifacts) | Yes (full filesystem) |
+| Schedules background jobs | No | Yes |
+| Web UI | Yes | Yes |
+| Messaging apps | No | Yes |
+| Self-hosted | No | Yes |
+| Provider-agnostic | No | Yes |
+| Open source | No | Yes |
+
+---
+
+## The Compounding Advantage
+
+What matters most about Hermes is that it improves over time. That is the point.
+
+Every time Hermes encounters a new environment, it saves facts to memory. Every time it solves
+a problem a new way, it saves the approach as a skill. Every time you correct it, it updates its
+profile of you. Every session, every scheduled job, every tool call, the agent gets more
+calibrated to you and your workflow.
+
+A Claude Code session on day one and day one hundred are identical. A Hermes agent on day one
+and day one hundred is smarter about you -- it knows your stack, your conventions, your
+preferences, and the solutions that have worked before.
+
+---
+
+## Who Hermes Is For
+
+**Solo developers and power users** who don't want to re-explain their stack every session and
+want an AI that actually knows their environment.
+
+**Teams on a shared server** where multiple people want Claude-quality AI access without each
+paying for a separate subscription or running local tooling.
+
+**Automation-heavy workflows** where you want an AI running tasks on a schedule, delivering
+results to your phone, without babysitting it.
+
+**Privacy-conscious users** who want their conversations, memory, and files on their own
+hardware.
+
+**Multi-model users** who want to switch between OpenAI, Anthropic, Google, DeepSeek, and
+others based on cost, capability, or rate limits, without rebuilding their workflow each time.
+
+---
+
+## Scope and Limits
+
+**Hermes lives in the terminal, browser, and messaging apps.** For in-editor autocomplete and
+inline diffs, use Cursor or Windsurf alongside it -- they do that job better.
+
+**You run Hermes on your own server.** That means initial setup, but your data stays on your
+hardware and you control the schedule, the models, and the costs.
+
+**Hermes is an orchestration and memory layer.** It makes whatever model you point it at more
+useful over time. The models do the reasoning; Hermes makes sure that reasoning accumulates into
+something durable.
+
+---
+
+## Quick Reference
+
+| | OpenClaw | Claude Code | Codex CLI | OpenCode | Cursor | Claude.ai | Hermes |
+|---|---|---|---|---|---|---|---|
+| Persistent memory (auto) | Yes | Partial† | Partial | Partial | No | Yes (improving) | **Yes** |
+| Scheduled / background jobs | Yes | Partial‡ | Partial§ | No | No | No | **Yes (self-hosted)** |
+| Messaging app access | Yes (15+ platforms) | Partial (Telegram/Discord preview; Slack native) | No | No | No | No | **Yes (10+ platforms)** |
+| Web UI | Dashboard only | Yes (Anthropic cloud) | No | Yes | No | Yes | **Yes (self-hosted)** |
+| Skills system | Yes (marketplace) | Yes (Hooks + Plugins) | No | No | No | No | **Yes** |
+| Self-improving skills | Partial | No | No | No | No | No | **Yes** |
+| Browser / computer control | Yes (Chrome CDP) | No | No | No | No | No | Via shell |
+| Python / ML ecosystem | No (Node.js) | No | No | No | No | No | **Yes** |
+| In-editor autocomplete | No | No | No | No | Yes | No | No |
+| Orchestrates other agents | No | No | No | No | No | No | **Yes** |
+| Provider-agnostic | Yes | No (Claude only) | Yes | Yes | Partial | No | **Yes** |
+| Self-hosted | Yes | No | Yes | Yes | No | No | **Yes** |
+| Open source | Yes (MIT) | No | Yes | Yes | No | No | **Yes** |
+| Always-on / autonomous | Yes | No | No | No | No | No | **Yes** |
+
+† Claude Code has CLAUDE.md / MEMORY.md project context and rolling auto-memory, but not full automatic cross-session recall  
+‡ Claude Code scheduling: cloud-managed (Anthropic infrastructure) or desktop-app only; no self-hosted cron  
+§ Codex scheduling: desktop app Automations only; CLI has no native scheduling

README.md

@@ -1,21 +1,99 @@
 # Hermes Web UI
 
-A lightweight, dark-themed browser interface for Hermes.
-Full parity with the CLI experience -- everything you can do from a terminal,
+[Hermes Agent](https://hermes-agent.nousresearch.com/) is a sophisticated autonomous agent that lives on your server, accessed via a terminal or messaging apps, remembers what it learns, and gets more capable the longer it runs.
+
+Hermes WebUI is a lightweight, dark-themed web app interface in your browser for [Hermes Agent](https://hermes-agent.nousresearch.com/).
+Full parity with the CLI experience - everything you can do from a terminal,
 you can do from this UI. No build step, no framework, no bundler. Just Python
 and vanilla JS.
 
 Layout: three-panel Claude-style. Left sidebar for sessions and tools,
 center for chat, right for workspace file browsing.
 
-<img width="1392" height="854" alt="image" src="https://github.com/user-attachments/assets/79cd3c0d-3167-42ed-9434-447a742c25c3" />
+<img alt="Hermes Web UI — three-panel layout" width="1417" height="867" alt="image" src="https://github.com/user-attachments/assets/51adff98-53ee-4800-8508-78b6c34dd3dc" />
 
-This gives you nearly **1:1 parity with Hermes CLI from a convenient web UI** which you can access securely through an SSH tunnel from your Hermes setup. Single command to start this up, and a single command to SSH tunnel for access on your computer. Every single part of the web UI leverages your existing Hermes agent, existing models, without requiring any setup.
+<table>
+  <tr>
+    <td width="50%" align="center">
+      <img alt="Light mode with full profile support" src="https://github.com/user-attachments/assets/9b68142f-d974-4493-a8d1-fd73e622c7fd" />
+      <br /><sub>Light mode with full profile support</sub>
+    </td>
+    <td width="50%" align="center">
+      <img alt="Customize your settings, configure a password" src="https://github.com/user-attachments/assets/941f3156-21e3-41fd-bcc8-f975d5000cb8" />
+      <br /><sub>Customize your settings, configure a password</sub>
+    </td>
+  </tr>
+</table>
+
+<table>
+  <tr>
+    <td width="50%" align="center">
+      <img alt="Workspace file browser with inline preview" src="docs/images/ui-workspace.png" />
+      <br /><sub>Workspace file browser with inline preview</sub>
+    </td>
+    <td width="50%" align="center">
+      <img alt="Session projects, tags, and tool call cards" src="docs/images/ui-sessions.png" />
+      <br /><sub>Session projects, tags, and tool call cards</sub>
+    </td>
+  </tr>
+</table>
+
+This gives you nearly **1:1 parity with Hermes CLI from a convenient web UI** which you can access securely through an SSH tunnel from your Hermes setup. Single command to start this up, and a single command to SSH tunnel for access on your computer. Every single part of the web UI uses your existing Hermes agent and existing models, without requiring any additional setup.
+
+---
+
+## Why Hermes
+
+Most AI tools reset every session. They don't know who you are, what you worked on, or what
+conventions your project follows. You re-explain yourself every time.
+
+Hermes retains context across sessions, runs scheduled jobs while you're offline, and gets
+smarter about your environment the longer it runs. It uses your existing Hermes agent setup,
+your existing models, and requires no additional configuration to start.
+
+What makes it different from other agentic tools:
+
+- **Persistent memory** — user profile, agent notes, and a skills system that saves reusable
+  procedures; Hermes learns your environment and does not have to relearn it
+- **Self-hosted scheduling** — cron jobs that fire while you're offline and deliver results to
+  Telegram, Discord, Slack, Signal, email, and more
+- **10+ messaging platforms** — the same agent available in the terminal is reachable from your phone
+- **Self-improving skills** — Hermes writes and saves its own skills automatically from experience;
+  no marketplace to browse, no plugins to install
+- **Provider-agnostic** — OpenAI, Anthropic, Google, DeepSeek, OpenRouter, and more
+- **Orchestrates other agents** — can spawn Claude Code or Codex for heavy coding tasks and bring
+  the results back into its own memory
+- **Self-hosted** — your conversations, your memory, your hardware
+
+**vs. the field** *(landscape is actively shifting — see [HERMES.md](HERMES.md) for the full breakdown)*:
+
+| | OpenClaw | Claude Code | Codex CLI | OpenCode | Hermes |
+|---|---|---|---|---|---|
+| Persistent memory (auto) | Yes | Partial† | Partial | Partial | Yes |
+| Scheduled jobs (self-hosted) | Yes | No‡ | No | No | Yes |
+| Messaging app access | Yes (15+ platforms) | Partial (Telegram/Discord preview) | No | No | Yes (10+) |
+| Web UI (self-hosted) | Dashboard only | No | No | Yes | Yes |
+| Self-improving skills | Partial | No | No | No | Yes |
+| Python / ML ecosystem | No (Node.js) | No | No | No | Yes |
+| Provider-agnostic | Yes | No (Claude only) | Yes | Yes | Yes |
+| Open source | Yes (MIT) | No | Yes | Yes | Yes |
+
+† Claude Code has CLAUDE.md / MEMORY.md project context and rolling auto-memory, but not full automatic cross-session recall  
+‡ Claude Code has cloud-managed scheduling (Anthropic infrastructure) and session-scoped `/loop`; no self-hosted cron
+
+**The closest competitor is OpenClaw** — both are always-on, self-hosted, open-source agents
+with memory, cron, and messaging. The key differences: Hermes writes and saves its own skills
+automatically as a core behavior (OpenClaw's skill system centers on a community marketplace);
+Hermes is more stable across updates (OpenClaw has documented release regressions and ClawHub
+has had security incidents involving malicious skills); and Hermes runs natively in the Python
+ecosystem. See [HERMES.md](HERMES.md) for the full side-by-side.
 
 ---
 
 ## Quick start
 
+First, you need to install and configure [Hermes Agent](https://hermes-agent.nousresearch.com/). Once installed:
+
 ```bash
 git clone https://github.com/nesquena/hermes-webui.git hermes-webui
 cd hermes-webui
@@ -31,6 +109,44 @@ That is it. The script will:
 
 ---
 
+## Docker
+
+**Pre-built images** (amd64 + arm64) are published to GHCR on every release:
+
+```bash
+docker pull ghcr.io/nesquena/hermes-webui:latest
+docker run -d -p 8787:8787 -v ~/.hermes:/root/.hermes ghcr.io/nesquena/hermes-webui:latest
+```
+
+Or run with Docker Compose (recommended):
+
+```bash
+docker compose up -d
+```
+
+Or build locally:
+
+```bash
+docker build -t hermes-webui .
+docker run -d -p 8787:8787 -v ~/.hermes:/root/.hermes hermes-webui
+```
+
+Open http://localhost:8787 in your browser.
+
+To enable password protection:
+
+```bash
+docker run -d -p 8787:8787 -e HERMES_WEBUI_PASSWORD=your-secret -v ~/.hermes:/root/.hermes ghcr.io/nesquena/hermes-webui:latest
+```
+
+Session data persists in a named volume (`hermes-data`) across restarts.
+
+> **Note:** By default, Docker Compose binds to `127.0.0.1` (localhost only).
+> To expose on a network, change the port to `"8787:8787"` in `docker-compose.yml`
+> and set `HERMES_WEBUI_PASSWORD` to enable authentication.
+
+---
+
 ## What start.sh discovers automatically
 
 | Thing | How it finds it |
@@ -71,7 +187,8 @@ Full list of environment variables:
 | `HERMES_WEBUI_STATE_DIR` | `~/.hermes/webui-mvp` | Where sessions and state are stored |
 | `HERMES_WEBUI_DEFAULT_WORKSPACE` | `~/workspace` | Default workspace |
 | `HERMES_WEBUI_DEFAULT_MODEL` | `openai/gpt-5.4-mini` | Default model |
-| `HERMES_HOME` | `~/.hermes` | Base directory for Hermes state (affects all paths above) |
+| `HERMES_WEBUI_PASSWORD` | *(unset)* | Set to enable password authentication |
+| `HERMES_HOME` | `~/.hermes` | Base directory for Hermes state (affects all paths) |
 | `HERMES_CONFIG_PATH` | `~/.hermes/config.yaml` | Path to Hermes config file |
 
 ---
@@ -98,6 +215,40 @@ are running over SSH.
 
 ---
 
+## Accessing on your phone with Tailscale
+
+[Tailscale](https://tailscale.com) is a zero-config mesh VPN built on
+WireGuard. Install it on your server and your phone, and they join the same
+private network -- no port forwarding, no SSH tunnels, no public exposure.
+
+The Hermes Web UI is fully responsive with a mobile-optimized layout
+(hamburger sidebar, bottom navigation bar, touch-friendly controls), so it
+works well as a daily-driver agent interface from your phone.
+
+**Setup:**
+
+1. Install [Tailscale](https://tailscale.com/download) on your server and
+   your iPhone/Android.
+2. Start the WebUI listening on all interfaces with password auth enabled:
+
+```bash
+HERMES_WEBUI_HOST=0.0.0.0 HERMES_WEBUI_PASSWORD=your-secret ./start.sh
+```
+
+3. Open `http://<server-tailscale-ip>:8787` in your phone's browser
+   (find your server's Tailscale IP in the Tailscale app or with
+   `tailscale ip -4` on the server).
+
+That's it. Traffic is encrypted end-to-end by WireGuard, and password auth
+protects the UI at the application level. You can add it to your home screen
+for an app-like experience.
+
+> **Tip:** If using Docker, set `HERMES_WEBUI_HOST=0.0.0.0` in your
+> `docker-compose.yml` environment (already the default) and set
+> `HERMES_WEBUI_PASSWORD`.
+
+---
+
 ## Manual launch (without start.sh)
 
 If you prefer to launch the server directly:
@@ -123,17 +274,18 @@ Tests discover the repo and the Hermes agent dynamically -- no hardcoded paths.
 
 ```bash
 cd hermes-webui
-python -m pytest tests/ -v
+pytest tests/ -v --timeout=60
 ```
 
 Or using the agent venv explicitly:
 
 ```bash
-/path/to/hermes-agent/venv/bin/python -m pytest tests/ -v   # or any Python with deps installed
+/path/to/hermes-agent/venv/bin/python -m pytest tests/ -v
 ```
 
 Tests run against an isolated server on port 8788 with a separate state directory.
-Production data and real cron jobs are never touched.
+Production data and real cron jobs are never touched. Current count: **433 tests**
+across 23 test files.
 
 ---
 
@@ -141,88 +293,161 @@ Production data and real cron jobs are never touched.
 
 ### Chat and agent
 - Streaming responses via SSE (tokens appear as they are generated)
-- Multi-provider model support -- any Hermes API provider (OpenAI, Anthropic, Google, DeepSeek, Nous Portal, OpenRouter); dynamic model dropdown populated from configured keys
+- Multi-provider model support -- any Hermes API provider (OpenAI, Anthropic, Google, DeepSeek, Nous Portal, OpenRouter, MiniMax, Z.AI); dynamic model dropdown populated from configured keys
 - Send a message while one is processing -- it queues automatically
 - Edit any past user message inline and regenerate from that point
 - Retry the last assistant response with one click
 - Cancel a running task from the activity bar
-- Tool call cards inline -- each shows the tool name, args, and result snippet
+- Tool call cards inline -- each shows the tool name, args, and result snippet; expand/collapse all toggle for multi-tool turns
+- Subagent delegation cards -- child agent activity shown with distinct icon and indented border
 - Mermaid diagram rendering inline (flowcharts, sequence diagrams, gantt charts)
+- Thinking/reasoning display -- collapsible gold-themed cards for Claude extended thinking and o3 reasoning blocks
 - Approval card for dangerous shell commands (allow once / session / always / deny)
 - SSE auto-reconnect on network blips (SSH tunnel resilience)
 - File attachments persist across page reloads
 - Message timestamps (HH:MM next to each message, full date on hover)
+- Code block copy button with "Copied!" feedback
+- Syntax highlighting via Prism.js (Python, JS, bash, JSON, SQL, and more)
+- Safe HTML rendering in AI responses (bold, italic, code converted to markdown)
+- rAF-throttled token streaming for smoother rendering during long responses
+- Context usage indicator in composer footer -- token count, cost, and fill bar (model-aware)
 
 ### Sessions
 - Create, rename, duplicate, delete, search by title and message content
-- Pin/star sessions to the top of the sidebar
+- Pin/star sessions to the top of the sidebar (gold indicator)
 - Archive sessions (hide without deleting, toggle to show)
+- Session projects -- named groups with colors for organizing sessions
 - Session tags -- add #tag to titles for colored chips and click-to-filter
-- Grouped by Today / Yesterday / Earlier in the sidebar
+- Grouped by Today / Yesterday / Earlier in the sidebar (collapsible date groups)
 - Download as Markdown transcript, full JSON export, or import from JSON
 - Sessions persist across page reloads and SSH tunnel reconnects
 - Browser tab title reflects the active session name
+- CLI session bridge -- CLI sessions from hermes-agent's SQLite store appear in the sidebar with a gold "cli" badge; click to import with full history and reply normally
+- Token/cost display -- input tokens, output tokens, estimated cost shown per conversation (toggle in Settings or `/usage` command)
 
 ### Workspace file browser
-- Browse directory tree with type icons
+- Directory tree with expand/collapse (single-click toggles, double-click navigates)
+- Breadcrumb navigation with clickable path segments
 - Preview text, code, Markdown (rendered), and images inline
 - Edit, create, delete, and rename files; create folders
+- Binary file download (auto-detected from server)
+- File preview auto-closes on directory navigation (with unsaved-edit guard)
+- Git detection -- branch name and dirty file count badge in workspace header
 - Right panel is drag-resizable
 - Syntax highlighted code preview (Prism.js)
 
+### Voice input
+- Microphone button in the composer (Web Speech API)
+- Tap to record, tap again or send to stop
+- Live interim transcription appears in the textarea
+- Auto-stops after ~2s of silence
+- Appends to existing textarea content (doesn't replace)
+- Hidden when browser doesn't support Web Speech API (Chrome, Edge, Safari)
+
+### Profiles
+- Profile picker in the topbar -- purple chip with dropdown showing all profiles
+- Gateway status dots (green = running), model info, skill count per profile
+- Profiles management panel -- create, switch, and delete profiles from the sidebar
+- Clone config from active profile on create
+- Seamless switching -- no server restart; reloads config, skills, memory, cron, models
+- Per-session profile tracking (records which profile was active at creation)
+
+### Authentication and security
+- Optional password auth -- off by default, zero friction for localhost
+- Enable via `HERMES_WEBUI_PASSWORD` env var or Settings panel
+- Signed HMAC HTTP-only cookie with 24h TTL
+- Minimal dark-themed login page at `/login`
+- Security headers on all responses (X-Content-Type-Options, X-Frame-Options, Referrer-Policy)
+- 20MB POST body size limit
+- CDN resources pinned with SRI integrity hashes
+
+### Themes
+- 6 built-in themes: Dark (default), Light, Slate, Solarized Dark, Monokai, Nord
+- Switch via Settings panel dropdown (instant live preview) or `/theme` command
+- Persists across reloads (server-side in settings.json + localStorage for flicker-free loading)
+- Custom themes: define a `:root[data-theme="name"]` CSS block and it works — see [THEMES.md](THEMES.md)
+
 ### Settings and configuration
-- Settings panel (gear icon in topbar) -- persist default model and default workspace server-side
+- Settings panel (gear icon) -- default model, default workspace, send key, theme
+- Send key: Enter (default) or Ctrl/Cmd+Enter
+- Show/hide CLI sessions toggle (enabled by default)
+- Token usage display toggle (off by default, also via `/usage` command)
+- Unsaved changes guard -- discard/save prompt when closing with unpersisted changes
 - Cron completion alerts -- toast notifications and unread badge on Tasks tab
 - Background agent error alerts -- banner when a non-active session encounters an error
 
+### Slash commands
+- Type `/` in the composer for autocomplete dropdown
+- Built-in: `/help`, `/clear`, `/model <name>`, `/workspace <name>`, `/new`, `/usage`, `/theme`, `/compact`
+- Arrow keys navigate, Tab/Enter select, Escape closes
+- Unrecognized commands pass through to the agent
+
 ### Panels
-- **Chat** -- session list, search, pin, archive, new conversation
-- **Tasks** -- view, create, edit, run, pause/resume, delete cron jobs; completion alerts
-- **Skills** -- list all skills by category, search, preview, create/edit/delete
+- **Chat** -- session list, search, pin, archive, projects, new conversation
+- **Tasks** -- view, create, edit, run, pause/resume, delete cron jobs; run history; completion alerts
+- **Skills** -- list all skills by category, search, preview, create/edit/delete; linked files viewer
 - **Memory** -- view and edit MEMORY.md and USER.md inline
+- **Profiles** -- create, switch, delete agent profiles; clone config
 - **Todos** -- live task list from the current session
 - **Spaces** -- add, rename, remove workspaces; quick-switch from topbar
 
+### Mobile responsive
+- Hamburger sidebar -- slide-in overlay on mobile (<640px)
+- Bottom navigation bar -- 5-tab iOS-style fixed bar
+- Files slide-over panel from right edge
+- Touch targets minimum 44px on all interactive elements
+- Composer positioned above bottom nav
+- Desktop layout completely unchanged
+
 ---
 
 ## Architecture
 
 ```
-server.py               HTTP routing shell (~76 lines)
+server.py               HTTP routing shell + auth middleware (~83 lines)
 api/
-  routes.py             All GET + POST route handlers
-  config.py             Discovery + globals + model provider detection
-  helpers.py            HTTP helpers: j(), bad(), require(), safe_resolve()
-  models.py             Session model + CRUD
-  workspace.py          File ops: list_dir, read_file_content, workspace helpers
-  upload.py             Multipart parser, file upload handler
-  streaming.py          SSE engine, run_agent integration, cancel support
+  auth.py               Optional password authentication, signed cookies (~149 lines)
+  config.py             Discovery, globals, model detection, reloadable config (~726 lines)
+  helpers.py            HTTP helpers, security headers (~71 lines)
+  models.py             Session model + CRUD + CLI bridge (~338 lines)
+  profiles.py           Profile state management, hermes_cli wrapper (~366 lines)
+  routes.py             All GET + POST route handlers (~1314 lines)
+  streaming.py          SSE engine, run_agent, cancel support (~332 lines)
+  upload.py             Multipart parser, file upload handler (~78 lines)
+  workspace.py          File ops, workspace helpers, git detection (~288 lines)
 static/
-  index.html            HTML template
-  style.css             All CSS
-  ui.js                 DOM helpers, renderMd, Mermaid, tool cards, file tree
-  workspace.js          File tree, preview, file ops
-  sessions.js           Session CRUD, list rendering, search, tags, archive
-  messages.js           send(), SSE event handlers, approval, transcript
-  panels.js             Cron, skills, memory, workspace, todo, switchPanel, alerts
-  boot.js               Event wiring + boot IIFE
+  index.html            HTML template (~388 lines)
+  style.css             All CSS incl. mobile responsive (~726 lines)
+  ui.js                 DOM helpers, renderMd, tool cards, context indicator (~1063 lines)
+  workspace.js          File preview, file ops, git badge (~247 lines)
+  sessions.js           Session CRUD, collapsible groups, search (~589 lines)
+  messages.js           send(), SSE handlers, rAF throttle (~352 lines)
+  panels.js             Cron, skills, memory, profiles, settings (~1146 lines)
+  commands.js           Slash command autocomplete (~170 lines)
+  boot.js               Mobile nav, voice input, boot IIFE (~338 lines)
 tests/
-  conftest.py           Isolated test server (port 8788, separate HERMES_HOME)
-  test_sprint1-14.py    Feature tests per sprint
-  test_regressions.py   Permanent regression gate
+  conftest.py           Isolated test server (port 8788)
+  test_sprint{1-23}.py  22 test files, 426 test functions
+  test_regressions.py   Permanent regression gate (23 tests)
+Dockerfile              python:3.12-slim container image
+docker-compose.yml      Compose with named volume and optional auth
+.github/workflows/      CI: multi-arch Docker build + GitHub Release on tag
 ```
 
 State lives outside the repo at `~/.hermes/webui-mvp/` by default
-(sessions, workspaces, settings, last_workspace). Override with `HERMES_WEBUI_STATE_DIR`.
+(sessions, workspaces, settings, projects, last_workspace). Override with `HERMES_WEBUI_STATE_DIR`.
 
 ---
 
 ## Docs
 
+- `HERMES.md` -- why Hermes, mental model, and detailed comparison to Claude Code / Codex / OpenCode / Cursor
 - `ROADMAP.md` -- feature roadmap and sprint history
 - `ARCHITECTURE.md` -- system design, all API endpoints, implementation notes
 - `TESTING.md` -- manual browser test plan and automated coverage reference
-- `CHANGELOG.md` -- release notes
+- `CHANGELOG.md` -- release notes per sprint
+- `SPRINTS.md` -- forward sprint plan with CLI + Claude parity targets
+- `THEMES.md` -- theme system documentation, custom theme guide
 
 ## Repo
 

ROADMAP.md

@@ -3,8 +3,8 @@
 > Goal: Full 1:1 parity with the Hermes CLI experience via a clean dark web UI.
 > Everything you can do from the CLI terminal, you can do from this UI.
 >
-> Last updated: Sprint 14 (March 30, 2026)
-> Tests: 226/226 passing
+> Last updated: v0.36 (April 5, 2026)
+> Tests: 433 total (433 passing, 0 failures)
 > Source: <repo>/
 
 ---
@@ -30,6 +30,23 @@
 | Sprint 11 | Multi-provider models + streaming | Dynamic model dropdown (any Hermes provider), smooth scroll pinning, routes extracted to api/routes.py (server.py 704→76 lines) | 201 |
 | Sprint 12 | Settings + reliability + session QoL | Settings panel (gear icon, settings.json), SSE auto-reconnect, pin sessions, import session from JSON | 211 |
 | Sprint 13 | Alerts + polish | Cron completion alerts (polling + badge), background error banner, session duplicate, browser tab title | 221 |
+| Sprint 14 | Visual polish + workspace ops | Mermaid diagrams, message timestamps, file rename, folder create, session tags, session archive | 233 |
+| Sprint 15 | Session projects + code copy | Session projects/folders, code block copy button, tool card expand/collapse toggle | 237 |
+| Sprint 16 | Session sidebar visual polish | SVG action icons, overlay hover actions, pin indicator, project border, safe HTML rendering | 289 |
+| Sprint 17 | Workspace polish + slash commands + settings | Breadcrumb navigation, slash command autocomplete, send key setting (#26) | 318 |
+| Sprint 18 | Thinking display + workspace tree | File preview auto-close, thinking/reasoning cards, expandable directory tree (#22) | 318 |
+| Sprint 19 | Auth + security hardening | Password auth (off by default), login page, security headers, 20MB body limit (#23) | 328 |
+| Sprint 20 | Voice input + send button | Voice input (Web Speech API), send button icon-circle with pop-in animation | 415 |
+| Sprint 21 | Mobile responsive + Docker | Hamburger sidebar, bottom nav, files slide-over, Docker support (#21, #7) | 415 |
+| Sprint 22 | Multi-profile support | Profile picker, management panel, seamless switching, per-session tracking (#28) | 415 |
+| Sprint 23 | Agentic transparency | Token/cost display, subagent cards, skill picker in cron, skill linked files, workspace tree persistence, timestamp fixes | 424 |
+| v0.32 | Auto-compaction handling | Compression detection, /compact command, real context window indicator | 424 |
+| v0.33 | /insights sync | Opt-in state.db sync so `hermes /insights` includes WebUI sessions | 424 |
+| v0.34 | Sprint 26 — Pluggable themes | Dark, Light, Slate, Solarized, Monokai, Nord; settings unsaved-changes guard; /theme command | 433 |
+| v0.34.1 | Theme variable polish | 30+ hardcoded dark-navy colors replaced with theme-aware CSS variables | 433 |
+| v0.34.2 | Theme text colors | 5 new per-theme typography variables (--strong, --em, --code-text, --code-inline-bg, --pre-text) | 433 |
+| v0.34.3 | Light theme final polish | 46 light-scoped selector overrides for sidebar, roles, chips, interactive elements | 433 |
+| v0.35 | Security hardening | Env race fix, random signing key, upload path traversal, PBKDF2 password hash | 433 |
 
 ---
 
@@ -37,10 +54,12 @@
 
 | Layer | Location | Status |
 |-------|----------|--------|
-| Python server | <repo>/server.py (~76 lines) + api/ modules (~1900 lines) | Thin shell + business logic in api/ |
-| HTML template | <repo>/static/index.html | Served from disk |
-| CSS | <repo>/static/style.css | Served from disk |
-| JavaScript | <repo>/static/{ui,workspace,sessions,messages,panels,boot}.js | 6 modules, ~2250 lines total |
+| Python server | <repo>/server.py (~81 lines) + api/ modules (~3210 lines) | Thin shell + auth middleware + business logic in api/ |
+| HTML template | <repo>/static/index.html (~364 lines) | Served from disk |
+| CSS | <repo>/static/style.css (~670 lines) | Served from disk, incl. mobile responsive |
+| JavaScript | <repo>/static/{ui,workspace,sessions,messages,panels,boot,commands}.js | 7 modules, ~3610 lines total |
+| Docker | Dockerfile, docker-compose.yml, .dockerignore | python:3.12-slim, multi-arch (amd64+arm64) |
+| CI/CD | .github/workflows/release.yml | Auto-release + GHCR publish on tag push |
 | Runtime state | ~/.hermes/webui-mvp/sessions/ | Session JSON files |
 | Test server | Port 8788, state dir ~/.hermes/webui-mvp-test/ | Isolated, wiped per run |
 | Production server | Port 8787 | SSH tunnel from Mac |
@@ -53,6 +72,7 @@
 - [x] Send messages, get SSE-streaming responses
 - [x] Switch models per session (10 models, grouped by provider)
 - [x] Multi-provider API support: use any Hermes agent API provider (OpenAI, Anthropic, Google, etc.) directly, not just OpenRouter (Sprint 11)
+- [x] Custom endpoint model discovery: auto-detect models from Ollama, LM Studio, and other local LLM servers via base_url (PR #18)
 - [x] Upload files to workspace (drag-drop, click, clipboard paste)
 - [x] File tray with remove button
 - [x] Tool progress shown in activity bar above composer
@@ -64,7 +84,7 @@
 - [x] Copy message to clipboard (hover icon on each bubble)
 - [x] Edit last user message and regenerate
 - [ ] Branch/fork conversation (Wave 3)
-- [ ] Token/cost estimate per message (Wave 3)
+- [x] Token/cost estimate per message (Sprint 23)
 
 ### Tool Visibility
 - [x] Tool progress in activity bar (moved out of composer footer)
@@ -103,6 +123,7 @@
 - [x] Import session from JSON (Sprint 12)
 - [x] Pin/star sessions to top of list (Sprint 12)
 - [x] Duplicate session (Sprint 13)
+- [x] Session projects / folders (Sprint 15)
 
 ### Workspace Management
 - [x] Add workspace with path validation (must be existing directory)
@@ -124,7 +145,7 @@
 - [x] Edit existing cron job
 - [x] Delete cron job
 - [x] View full cron run history (expandable per job)
-- [ ] Skill picker in cron create form (Wave 3)
+- [x] Skill picker in cron create form (Sprint 23)
 
 ### Skills
 - [x] List all skills grouped by category (Skills sidebar tab)
@@ -133,7 +154,7 @@
 - [x] Create skill
 - [x] Edit skill
 - [x] Delete skill
-- [ ] View skill linked files (Wave 3)
+- [x] View skill linked files (Sprint 23)
 
 ### Memory
 - [x] View personal notes (MEMORY.md) rendered as markdown (Memory tab)
@@ -143,22 +164,59 @@
 
 ### Configuration
 - [x] Settings panel (default model, default workspace) (Sprint 12)
+- [x] Send key preference (Enter or Ctrl+Enter) (Sprint 17)
+- [x] Password authentication (Sprint 19)
 - [ ] Enable/disable toolsets per session (deferred)
 
 ### Notifications
 - [x] Cron job completion alerts (Sprint 13)
 - [x] Background agent error alerts (Sprint 13)
 
+### Workspace
+- [x] Breadcrumb navigation in subdirectories (Sprint 17)
+- [x] Workspace tree view with expand/collapse (Sprint 18, Issue #22)
+- [x] File preview auto-close on directory navigation (Sprint 18)
+
+### Slash Commands
+- [x] Command registry + autocomplete dropdown (Sprint 17)
+- [x] Built-in: /help, /clear, /model, /workspace, /new (Sprint 17)
+
+### Security
+- [x] Password auth with signed cookies (Sprint 19, Issue #23)
+- [x] Security headers (X-Content-Type-Options, X-Frame-Options) (Sprint 19)
+- [x] POST body size limit (20MB) (Sprint 19)
+
+### Thinking / Reasoning
+- [x] Collapsible thinking cards for extended-thinking models (Sprint 18)
+
+### Voice
+- [x] Voice input via Web Speech API (Sprint 20)
+
+### Mobile
+- [x] Mobile responsive layout — hamburger sidebar, bottom nav, files slide-over (Sprint 21)
+
+### Profiles
+- [x] Multi-profile support — create, switch, delete profiles (Sprint 22, Issue #28)
+
 ### Advanced / Future
-- [ ] Voice input via Whisper (Wave 6)
-- [ ] TTS playback of responses (Wave 6)
-- [ ] Subagent delegation cards (Wave 6)
+- [ ] Subagent session tree -- show subagent hierarchy in sidebar with expand/collapse (PR #75)
+- [ ] Specialized tool card renderers -- diff viewer, terminal output, todo checklist views (PR #75)
+- [x] Streaming performance -- rAF-throttled token rendering (Sprint 24, PR #81)
+- [x] Workspace git detection -- branch name and dirty status badge (Sprint 24, PR #82)
+- [x] Collapsible date groups -- click group headers to collapse (Sprint 24, PR #80)
+- [x] Context usage indicator -- token count and cost in composer footer (Sprint 24, PR #83)
+- [ ] LLM-generated session titles -- auto-title via small model instead of first-message substring (PR #75)
+- [ ] Workspace git detection -- show branch name, dirty status in workspace header (PR #75)
+- [ ] Clarify dialog -- agent can ask clarifying questions that block until user responds (PR #75)
+- [ ] Gateway approval polling -- support blocking approvals from messaging gateway (PR #75)
+- [ ] Unified session storage -- SessionDB shared between webui and CLI (PR #75)
+- [ ] TTS playback of responses (deferred)
 - [x] Background task cancel (activity bar Cancel button)
-- [ ] Code execution cell (Wave 6)
-- [ ] Password authentication (Wave 7)
-- [ ] HTTPS / reverse proxy (Wave 7)
-- [ ] Mobile responsive layout (Wave 7)
-- [ ] Virtual scroll for large lists (Wave 7)
+- [ ] Code execution cell (deferred)
+- [ ] Desktop application (Sprint 25, PLANNED)
+- [x] Pluggable UI themes -- Dark, Light, Slate, Solarized, Monokai, Nord (Sprint 26, v0.34)
+- [ ] Extended slash command / skill integration (deferred)
+- [ ] Virtual scroll for large lists (deferred)
 
 ---
 
@@ -235,81 +293,29 @@ Enter saves, Escape cancels. Topbar updates immediately.
 
 ---
 
-## Wave 3: Power Features and Developer Experience
+## Completed Waves (Summary)
 
-### Sprint 3.1: Tool Call Visibility Inline
-Show tool calls as collapsible cards in the conversation.
-Collapsed: tool name badge + one-line preview. Expanded: full args + result.
-
-### Sprint 3.2: Multi-Model Expansion
-Add more models. Group by provider. Model info tooltip on hover.
-(Partially done: 10 models in dropdown from Sprint 1.)
-
-### Sprint 3.2b: Resizable Panel Widths (COMPLETE Sprint 6)
-Both sidebar and workspace panel are drag-resizable with localStorage persistence.
-
-### Sprint 3.3: Workspace File Actions
-- [ ] Rename file (inline, double-click) (Wave 3)
-- [ ] Create folder (Wave 3)
-- [x] Syntax highlighted code preview (Prism.js)
-
-### Sprint 3.4: Conversation Controls
-- [x] Copy message (Sprint 5)
-- [x] Edit last user message + regenerate
-- [x] Regenerate last assistant response
-- [x] Clear conversation (wipe messages, keep session)
+| Wave | Theme | Key Deliverables |
+|------|-------|-----------------|
+| Wave 2 | Full CRUD + Interaction | Cron/skill/memory CRUD, session search, workspace management, session rename |
+| Wave 3 | Power Features | Tool call cards, multi-model dropdown, resizable panels, file actions, conversation controls |
+| Wave 4 | Settings + Notifications | Settings panel, cron alerts, background error banner |
+| Wave 5 | Session Continuity | Session tags, archive, projects/folders |
+| Wave 6 | Agentic Features | Background task cancel, voice input (Web Speech API) |
+| Wave 7 | Production Hardening | Password auth, security headers, mobile responsive, Docker + GHCR CI |
 
 ---
 
-## Wave 4: Settings, Configuration, Notifications
+## User Requested Features
 
-### Sprint 4.1: Settings Panel
-Full settings overlay: default model, default workspace, enabled toolsets, config viewer.
+Community-requested enhancements tracked from GitHub issues. All shipped.
 
-### Sprint 4.2: Notification Panel
-Bell icon with unread count. SSE endpoint for cron completions and errors. Toast pop-ups.
-
-### Sprint 4.3: Delivery Target Config
-Configure and test-ping delivery targets (Discord, Telegram, Slack, email) for cron jobs.
-
----
-
-## Wave 5: Honcho Integration and Long-term Memory
-
-### Sprint 5.1: Honcho Memory Panel
-User representation panel, cross-session context, Honcho search, memory write.
-
-### Sprint 5.2: Session Continuity Features
-"What were we working on?" button, session tags, session archive.
-
----
-
-## Wave 6: Realtime and Agentic Features
-
-### Sprint 6.1: Background Task Monitor
-Live list of running agent threads. Cancel button. Queue visibility.
-
-### Sprint 6.2: Subagent Delegation Cards
-When delegate_task fires, show subagent progress inline in chat.
-
-### Sprint 6.3: Code Execution Panel
-Jupyter-style inline code cell. Stateful kernel per session.
-
-### Sprint 6.4: Voice Mode
-Push-to-talk mic button. Whisper transcription. Optional TTS playback.
-
----
-
-## Wave 7: Production Hardening and Mobile
-
-### Sprint 7.1: Authentication
-HERMES_WEBUI_PASSWORD env var gate. Signed cookie. Login page.
-
-### Sprint 7.2: HTTPS and Reverse Proxy
-Nginx + Let's Encrypt. CORS headers for external domain.
-
-### Sprint 7.3: Mobile Responsive Layout
-Collapsible sidebar hamburger. Touch-friendly controls. Swipe gestures.
-
-### Sprint 7.4: Performance and Scale
-Virtual scroll for session/message lists. Incremental message loading.
+| Feature | Issue | Shipped | Sprint |
+|---------|-------|---------|--------|
+| Workspace tree view | #22 | Done | Sprint 18 |
+| Docker container + GHCR images | #7 | Done | Sprint 21 + v0.28.1 CI |
+| Authentication | #23 | Done | Sprint 19 |
+| Send key / personalization | #26 | Done | Sprint 17 |
+| Multi-profile support | #28 | Done | Sprint 22 |
+| Mobile responsive UI | #21 | Done | Sprint 21 |
+| Profile creation in Docker | #44 | Done | v0.27 |

TESTING.md

@@ -1,12 +1,15 @@
 # Hermes Web UI: Browser Testing Plan
 
 > This document is for manual browser testing by you or by a Claude browser agent.
-> It covers every user-facing feature of the UI through Sprint 2.
+> It covers user-facing features of the UI through Sprint 26 (v0.36).
 > Each section is written as a step-by-step test procedure with expected outcomes.
 > A browser agent (e.g. Claude with Chrome access) can execute this plan directly.
 >
-> Prerequisites: SSH tunnel is active on port 8787. Open http://localhost:8787 in browser.
-> Server health check: curl http://127.0.0.1:8787/health should return {"status":"ok"}.
+> Prerequisites: SSH tunnel is active on port 8786. Open http://localhost:8786 in browser.
+> Server health check: curl http://127.0.0.1:8786/health should return {"status":"ok"}.
+>
+> Automated tests: 465 total (461 passing, 4 known isolation failures in test_sprint28)
+> Run: `pytest tests/ -v --timeout=60`
 
 ---
 
@@ -1593,8 +1596,120 @@ FAIL: User message gone, blank chat, response lands in wrong session.
 
 ---
 
-*Last updated: Post-Sprint 10 concurrency sweeps, March 31, 2026*
-*Total automated tests: 190/190*
-*Regression gate: tests/test_regressions.py (23 tests, one per introduced bug)*
-*Run: python -m pytest tests/ -v*
+---
+
+## Sections Added Post-Sprint 10 (Sprints 11-19)
+
+The following features were added in Sprints 11-19 and need manual browser testing.
+Each has automated API-level tests in `tests/test_sprint{N}.py`.
+
+### Sprint 11: Multi-Provider Models
+- Open model dropdown. Verify models grouped by provider (OpenAI, Anthropic, Google, etc.)
+- If custom `base_url` configured in config.yaml, verify local models appear in dropdown.
+- Switch model. Send a message. Verify response uses selected model.
+
+### Sprint 12: Settings + Pin + Import
+- Click gear icon. Settings overlay opens.
+- Change default model, save. Restart server. Verify setting persisted.
+- Pin a session (star icon in hover overlay). Verify it floats to top of list.
+- Export session as JSON. Import it back. Verify messages restored.
+
+### Sprint 13: Alerts + Session QoL
+- Duplicate a session (copy icon in hover overlay). Verify "(copy)" title.
+- Browser tab title updates to active session name. Switch sessions — title changes.
+
+### Sprint 14: Visual Polish + Workspace Ops
+- Create a mermaid code block in a response. Verify diagram renders inline.
+- Message timestamps visible next to role labels (hover for full date).
+- Double-click a file in workspace panel to rename. Enter saves, Escape cancels.
+- Create a folder via folder icon in workspace header.
+- Add `#tag` to session title. Verify tag chip appears in sidebar. Click to filter.
+- Archive a session. Verify it disappears. Toggle "Show archived" to see it.
+
+### Sprint 15: Session Projects
+- Click "+" in project bar to create a project. Type name, Enter.
+- Click a project chip to filter sessions.
+- Hover a session → click folder icon → assign to project via picker.
+- Verify colored left border appears on assigned session.
+- Double-click project chip to rename. Right-click to delete.
+- Code blocks have a "Copy" button. Click → "Copied!" feedback.
+- Messages with 2+ tool cards show "Expand all / Collapse all" toggle.
+
+### Sprint 16: Sidebar Visual Polish
+- Session titles use full sidebar width (no truncated space for hidden icons).
+- Hover a session → action buttons appear from right with gradient fade.
+- All icons are monochrome SVGs (not emoji). Consistent across platforms.
+- Pinned sessions show small gold star inline. Unpinned = no star, full title width.
+- Active session has gold highlight (not blue). Overlay gradient matches.
+- Double-click to rename → overlay hides during rename.
+
+### Sprint 17: Workspace + Slash Commands + Send Key
+- Navigate into a subdirectory. Breadcrumb bar appears with clickable segments.
+- Up button in panel header navigates to parent. Hidden at root.
+- Type `/` in composer → autocomplete dropdown appears. Arrow keys navigate.
+- Type `/help` → lists all commands. `/clear` clears conversation. `/model` switches.
+- Settings panel: change send key to Ctrl+Enter. Verify Enter inserts newline.
+
+### Sprint 18: Thinking + Tree View + Preview Fix
+- View a file in workspace. Click a breadcrumb or folder → preview closes automatically.
+- Click a directory toggle arrow (▸) → expands in-place showing children.
+- Click again (▾) → collapses. Double-click navigates into it (breadcrumb view).
+- If model returns thinking blocks (Claude extended thinking), verify collapsible gold card appears above response.
+
+### Sprint 19: Auth + Security
+- No password set: everything works as normal. No login page.
+- Set `HERMES_WEBUI_PASSWORD=test` env var. Restart. All pages redirect to `/login`.
+- Login page: minimal card, password field, "Sign in" button.
+- Enter correct password → redirected to `/`. Cookie set (24h).
+- Enter wrong password → error message, stay on login page.
+- Settings panel: set password via "Access Password" field. Auth activates.
+- "Sign Out" button visible when auth active. Click → redirected to /login.
+- API calls without auth cookie → 401 JSON response.
+- Check response headers: `X-Content-Type-Options: nosniff`, `X-Frame-Options: DENY`.
+
+### Sprint 20: Voice Input + Send Button
+- Mic button visible in composer (Chrome/Edge). Hidden in Firefox.
+- Tap mic → button turns red with pulse, "Listening..." indicator appears.
+- Speak → live transcription appears in textarea.
+- Stop speaking → auto-stops after ~2s silence. Text stays editable.
+- Tap mic again or Send → stops recording, sends text.
+- Type text, then tap mic → spoken text appends to existing text (doesn't replace).
+- Send button hidden when textarea is empty. Appears with pop-in animation when typing.
+- Send button is icon-only circle (no "Send" text label). Blue with glow.
+- Attach a file with no text → send button appears.
+- Send message → button disappears after textarea clears.
+- While agent is responding → send button hidden.
+
+### Sprint 21: Mobile Responsive + Docker
+- Open on mobile viewport (<640px): hamburger icon visible in topbar.
+- Tap hamburger → sidebar slides in from left with backdrop overlay.
+- Tap outside sidebar → closes. Tap a session → closes and loads session.
+- Bottom navigation bar: 5 tabs (Chat, Tasks, Skills, Memory, Spaces).
+- Tap "Tasks" in bottom nav → sidebar opens showing Tasks panel.
+- Tap "Chat" in bottom nav → sidebar closes (chat is in main area).
+- Files button in topbar → right panel slides in from right.
+- All touch targets are at least 44px (session items, buttons, icons).
+- Desktop viewport (>640px): no hamburger, no bottom nav, no mobile elements.
+- Docker: `docker compose up -d` starts server on port 8787.
+- Docker: session data persists across container restarts (named volume).
+
+### Sprint 22: Multi-Profile Support
+- Profile chip in topbar (purple accent). Click → dropdown with all profiles.
+- Dropdown shows gateway status dots, model info, skill count per profile.
+- Click a profile → switches; model dropdown, skills, memory, cron refresh.
+- "Manage profiles" link opens Profiles sidebar panel.
+- Profiles panel: cards with name, model, provider, skill count, API key status.
+- "Use" button switches profile. Delete button removes non-default profiles.
+- "+ New profile" form: name validation (lowercase + hyphens), clone config checkbox.
+- Create profile → appears in list and dropdown.
+- Delete profile → confirm dialog. Auto-switches to default if deleting active.
+- Attempt switch while agent busy → blocked with toast message.
+- With hermes-agent not installed → only default profile shown, graceful fallback.
+
+---
+
+*Last updated: Sprint 26 / v0.36, April 5, 2026*
+*Total automated tests: 440 (440 passing, 0 failures)*
+*Regression gate: tests/test_regressions.py*
+*Run: pytest tests/ -v --timeout=60*
 *Source: <repo>/*

THEMES.md

@@ -0,0 +1,144 @@
+# Hermes Web UI — Themes
+
+Hermes Web UI supports pluggable color themes. Six themes ship built-in, and
+you can create your own with pure CSS — no Python changes needed.
+
+---
+
+## Switching Themes
+
+**Settings panel:** Click the gear icon, select a theme from the dropdown. The
+preview is instant — the UI updates as you click through options.
+
+**Slash command:** Type `/theme dark` or `/theme light` in the composer.
+
+**Themes persist** across page reloads and server restarts (stored in
+`settings.json` server-side, with `localStorage` for flicker-free loading).
+
+---
+
+## Built-in Themes
+
+| Theme | Description |
+|-------|-------------|
+| **Dark** (default) | Deep navy/indigo with muted blue accents. Easy on the eyes for long sessions. |
+| **Light** | Warm off-white with dark text. High contrast for bright environments. |
+| **Slate** | Warm charcoal, lighter than Dark. Easier on the eyes for extended use. |
+| **Solarized Dark** | Ethan Schoonover's classic dark palette. Teal background, warm accents. |
+| **Monokai** | Warm dark theme inspired by the Monokai editor scheme. Green/pink accents. |
+| **Nord** | Arctic blue-gray palette from the Nord color system. Calm and minimal. |
+| **Custom themes** | Any string accepted by `settings.json`, `POST /api/settings`, and `/theme` if added to the picker/command list. Pure CSS variables only. |
+
+---
+
+## Creating a Custom Theme
+
+A theme is a CSS block that overrides the color variables. Add it to
+`static/style.css` (or a separate file that you link after the main stylesheet).
+
+### Step 1: Define your theme block
+
+Every color in the UI comes from these CSS variables:
+
+```css
+:root[data-theme="your-theme-name"] {
+  /* Core palette */
+  --bg: #1a1a2e;          /* Main background */
+  --sidebar: #16213e;      /* Sidebar background */
+  --border: rgba(255,255,255,0.08);   /* Subtle borders */
+  --border2: rgba(255,255,255,0.14);  /* Stronger borders */
+  --text: #e8e8f0;         /* Primary text color */
+  --muted: #8888aa;        /* Secondary/muted text */
+  --accent: #e94560;       /* Accent color (errors, warnings, delete) */
+  --blue: #7cb9ff;         /* Primary action color (links, active states) */
+  --gold: #c9a84c;         /* Secondary accent (pinned items, gold highlights) */
+  --code-bg: #0d1117;      /* Code block background */
+
+  /* Surface and chrome (required for full theme polish) */
+  --surface: #1a2535;      /* Dropdowns, popups, toast, approval card */
+  --topbar-bg: rgba(22,33,62,.98);   /* Topbar background */
+  --main-bg: rgba(26,26,46,0.5);    /* Main chat area background */
+  --input-bg: rgba(255,255,255,.04); /* Input/button subtle backgrounds */
+  --hover-bg: rgba(255,255,255,.06); /* Hover state backgrounds */
+  --focus-ring: rgba(124,185,255,.35); /* Focus border color */
+  --focus-glow: rgba(124,185,255,.08); /* Focus box-shadow glow */
+
+  /* Typography (required for readable text across themes) */
+  --strong: #fff;          /* Bold text in messages */
+  --em: #c9c9e8;           /* Italic text in messages */
+  --code-text: #f0c27f;    /* Inline code text color */
+  --code-inline-bg: rgba(0,0,0,.35); /* Inline code background */
+  --pre-text: #e2e8f0;     /* Code block text color */
+}
+```
+
+The **core palette** controls the overall mood. The **surface/chrome** and
+**typography** variables are part of the standard theme contract — define all
+of them for a complete theme.
+
+For **light themes**, you also need `:root[data-theme="name"]` overrides
+for elements that use `rgba(255,255,255,.XX)` hover/border effects (these
+are invisible on light backgrounds). See the built-in light theme for the
+full pattern — it overrides ~45 selectors for proper dark-on-light contrast
+on hover states, borders, chips, role labels, session items, and
+interactive elements.
+
+### Step 2: Add it to the theme picker (optional)
+
+To make your theme appear in the Settings dropdown, add an `<option>` to the
+theme `<select>` in `static/index.html`:
+
+```html
+<option value="your-theme-name">Your Theme Name</option>
+```
+
+And update the `/theme` command's valid theme list in `static/commands.js`.
+
+### Step 3: Test it
+
+Switch to your theme via `/theme your-theme-name` or the Settings panel.
+Check these areas:
+- Sidebar session list (hover states, active state, project borders)
+- Message bubbles (user vs assistant styling)
+- Code blocks (background contrast, copy button visibility)
+- Tool cards (running indicator, expand/collapse)
+- Settings panel and login page
+- Mobile layout (hamburger sidebar, bottom nav)
+
+### Tips
+
+- **Light themes** need scrollbar and selection overrides, plus the full
+  text/code set (`--strong`, `--em`, `--code-text`, `--code-inline-bg`,
+  `--pre-text`) or they will look broken.
+- The **logo gradient** uses `--accent` automatically, so it adapts to your
+  theme without extra work.
+- **Prism.js syntax highlighting** uses its own CDN stylesheet (Tomorrow theme).
+  It works well on dark themes; on light themes the contrast is acceptable but
+  not perfect. Custom Prism theme support is planned for a future update.
+- **No server changes needed.** The `theme` setting in `settings.json` accepts
+  any string — your custom theme name will persist without code changes.
+
+---
+
+## How Themes Work Internally
+
+1. Each theme is a `:root[data-theme="name"]` CSS block that overrides variables.
+2. Switching themes sets `document.documentElement.dataset.theme = name` in JS.
+3. A tiny inline `<script>` in `<head>` reads `localStorage` before the
+   stylesheet loads — this prevents a flash of the wrong theme on page load.
+4. The theme preference is saved server-side via `POST /api/settings` and
+   loaded on boot via `GET /api/settings`.
+5. The `/theme` command and Settings dropdown both update the DOM, localStorage,
+   and server settings simultaneously.
+
+---
+
+## Contributing a Theme
+
+To contribute a new built-in theme:
+
+1. Add your `:root[data-theme="name"]` block to `static/style.css`
+2. Add the `<option>` to the Settings panel in `static/index.html`
+3. Add the theme name to the valid list in `cmdTheme()` in `static/commands.js`
+4. Test on desktop and mobile
+5. Open a PR — themes are pure CSS additions with no backend changes needed

api/auth.py

@@ -0,0 +1,170 @@
+"""
+Hermes Web UI -- Optional password authentication.
+Off by default. Enable by setting HERMES_WEBUI_PASSWORD env var
+or configuring a password in the Settings panel.
+"""
+import hashlib
+import hmac
+import http.cookies
+import os
+import secrets
+import time
+
+from api.config import STATE_DIR, load_settings
+
+# ── Public paths (no auth required) ─────────────────────────────────────────
+PUBLIC_PATHS = frozenset({
+    '/login', '/health', '/favicon.ico',
+    '/api/auth/login', '/api/auth/status',
+})
+
+COOKIE_NAME = 'hermes_session'
+SESSION_TTL = 86400  # 24 hours
+
+# Active sessions: token -> expiry timestamp
+_sessions = {}
+
+
+def _signing_key():
+    """Return a random signing key, generating and persisting one on first call."""
+    key_file = STATE_DIR / '.signing_key'
+    if key_file.exists():
+        try:
+            raw = key_file.read_bytes()
+            if len(raw) >= 32:
+                return raw[:32]
+        except Exception:
+            pass
+    # Generate a new random key
+    key = secrets.token_bytes(32)
+    try:
+        STATE_DIR.mkdir(parents=True, exist_ok=True)
+        key_file.write_bytes(key)
+        key_file.chmod(0o600)
+    except Exception:
+        pass  # key works for this process even if persist fails
+    return key
+
+
+def _hash_password(password):
+    """PBKDF2-SHA256 with 600k iterations (OWASP recommendation).
+    Salt is the persisted random signing key, which is secret and unique per
+    installation. This keeps the stored hash format a plain hex string
+    (no format change to settings.json) while replacing the predictable
+    STATE_DIR-derived salt from the original implementation."""
+    salt = _signing_key()
+    dk = hashlib.pbkdf2_hmac('sha256', password.encode(), salt, 600_000)
+    return dk.hex()
+
+
+def get_password_hash() -> str | None:
+    """Return the active password hash, or None if auth is disabled.
+    Priority: env var > settings.json."""
+    env_pw = os.getenv('HERMES_WEBUI_PASSWORD', '').strip()
+    if env_pw:
+        return _hash_password(env_pw)
+    settings = load_settings()
+    return settings.get('password_hash') or None
+
+
+def is_auth_enabled() -> bool:
+    """True if a password is configured (env var or settings)."""
+    return get_password_hash() is not None
+
+
+def verify_password(plain) -> bool:
+    """Verify a plaintext password against the stored hash."""
+    expected = get_password_hash()
+    if not expected:
+        return False
+    return hmac.compare_digest(_hash_password(plain), expected)
+
+
+def create_session() -> str:
+    """Create a new auth session. Returns signed cookie value."""
+    token = secrets.token_hex(32)
+    _sessions[token] = time.time() + SESSION_TTL
+    sig = hmac.new(_signing_key(), token.encode(), hashlib.sha256).hexdigest()[:16]
+    return f"{token}.{sig}"
+
+
+def verify_session(cookie_value) -> bool:
+    """Verify a signed session cookie. Returns True if valid and not expired."""
+    if not cookie_value or '.' not in cookie_value:
+        return False
+    token, sig = cookie_value.rsplit('.', 1)
+    expected_sig = hmac.new(_signing_key(), token.encode(), hashlib.sha256).hexdigest()[:16]
+    if not hmac.compare_digest(sig, expected_sig):
+        return False
+    expiry = _sessions.get(token)
+    if not expiry or time.time() > expiry:
+        _sessions.pop(token, None)
+        return False
+    return True
+
+
+def invalidate_session(cookie_value) -> None:
+    """Remove a session token."""
+    if cookie_value and '.' in cookie_value:
+        token = cookie_value.rsplit('.', 1)[0]
+        _sessions.pop(token, None)
+
+
+def parse_cookie(handler) -> str | None:
+    """Extract the auth cookie from the request headers."""
+    cookie_header = handler.headers.get('Cookie', '')
+    if not cookie_header:
+        return None
+    cookie = http.cookies.SimpleCookie()
+    try:
+        cookie.load(cookie_header)
+    except http.cookies.CookieError:
+        return None
+    morsel = cookie.get(COOKIE_NAME)
+    return morsel.value if morsel else None
+
+
+def check_auth(handler, parsed) -> bool:
+    """Check if request is authorized. Returns True if OK.
+    If not authorized, sends 401 (API) or 302 redirect (page) and returns False."""
+    if not is_auth_enabled():
+        return True
+    # Public paths don't require auth
+    if parsed.path in PUBLIC_PATHS or parsed.path.startswith('/static/'):
+        return True
+    # Check session cookie
+    cookie_val = parse_cookie(handler)
+    if cookie_val and verify_session(cookie_val):
+        return True
+    # Not authorized
+    if parsed.path.startswith('/api/'):
+        handler.send_response(401)
+        handler.send_header('Content-Type', 'application/json')
+        handler.end_headers()
+        handler.wfile.write(b'{"error":"Authentication required"}')
+    else:
+        handler.send_response(302)
+        handler.send_header('Location', '/login')
+        handler.end_headers()
+    return False
+
+
+def set_auth_cookie(handler, cookie_value) -> None:
+    """Set the auth cookie on the response."""
+    cookie = http.cookies.SimpleCookie()
+    cookie[COOKIE_NAME] = cookie_value
+    cookie[COOKIE_NAME]['httponly'] = True
+    cookie[COOKIE_NAME]['samesite'] = 'Lax'
+    cookie[COOKIE_NAME]['path'] = '/'
+    cookie[COOKIE_NAME]['max-age'] = str(SESSION_TTL)
+    handler.send_header('Set-Cookie', cookie[COOKIE_NAME].OutputString())
+
+
+def clear_auth_cookie(handler) -> None:
+    """Clear the auth cookie on the response."""
+    cookie = http.cookies.SimpleCookie()
+    cookie[COOKIE_NAME] = ''
+    cookie[COOKIE_NAME]['httponly'] = True
+    cookie[COOKIE_NAME]['path'] = '/'
+    cookie[COOKIE_NAME]['max-age'] = '0'
+    handler.send_header('Set-Cookie', cookie[COOKIE_NAME].OutputString())

api/config.py

@@ -31,7 +31,7 @@ PORT = int(os.getenv('HERMES_WEBUI_PORT', '8787'))
 # ── State directory (env-overridable, never inside repo) ──────────────────────
 STATE_DIR = Path(os.getenv(
     'HERMES_WEBUI_STATE_DIR',
-    str(HOME / '.hermes' / 'webui-mvp')
+    str(HOME / '.hermes' / 'webui')
 )).expanduser().resolve()
 
 SESSION_DIR           = STATE_DIR / 'sessions'
@@ -39,6 +39,7 @@ WORKSPACES_FILE       = STATE_DIR / 'workspaces.json'
 SESSION_INDEX_FILE    = SESSION_DIR / '_index.json'
 SETTINGS_FILE         = STATE_DIR / 'settings.json'
 LAST_WORKSPACE_FILE   = STATE_DIR / 'last_workspace.txt'
+PROJECTS_FILE         = STATE_DIR / 'projects.json'
 
 # ── Hermes agent directory discovery ─────────────────────────────────────────
 def _discover_agent_dir() -> Path:
@@ -125,25 +126,66 @@ def _discover_python(agent_dir: Path) -> str:
 _AGENT_DIR = _discover_agent_dir()
 PYTHON_EXE = _discover_python(_AGENT_DIR)
 
-# ── Inject agent dir into sys.path so Hermes modules are importable ───────────
+# ── Inject agent dir into sys.path so Hermes modules are importable ──────────
+
+# When users (or CI builds) run `pip install --target .` or
+# `pip install -t .` inside the hermes-agent checkout, third-party
+# package directories (openai/, pydantic/, requests/, etc.) end up
+# alongside real Hermes source files.  Putting _AGENT_DIR at the
+# FRONT of sys.path means Python resolves `import pydantic` from that
+# local directory — which breaks whenever the host platform differs
+# from the container (e.g. macOS .so files inside a Linux image).
+#
+# Fix: insert _AGENT_DIR at the END of sys.path.  Python searches
+# entries in order, so site-packages resolves pip packages correctly,
+# and Hermes-specific modules (run_agent, hermes/, etc.) still
+# resolve because they do not exist in site-packages.
+
 if _AGENT_DIR is not None:
     if str(_AGENT_DIR) not in sys.path:
-        sys.path.insert(0, str(_AGENT_DIR))
+        sys.path.append(str(_AGENT_DIR))
     _HERMES_FOUND = True
 else:
     _HERMES_FOUND = False
 
-# ── Config file (optional YAML) ──────────────────────────────────────────────
-CONFIG_PATH = Path(os.getenv(
-    'HERMES_CONFIG_PATH',
-    str(HOME / '.hermes' / 'config.yaml')
-)).expanduser()
+# ── Config file (reloadable -- supports profile switching) ──────────────────
+_cfg_cache = {}
+_cfg_lock = threading.Lock()
 
-try:
-    import yaml as _yaml
-    cfg = _yaml.safe_load(CONFIG_PATH.read_text()) if CONFIG_PATH.exists() else {}
-except Exception:
-    cfg = {}
+def _get_config_path() -> Path:
+    """Return config.yaml path for the active profile."""
+    env_override = os.getenv('HERMES_CONFIG_PATH')
+    if env_override:
+        return Path(env_override).expanduser()
+    try:
+        from api.profiles import get_active_hermes_home
+        return get_active_hermes_home() / 'config.yaml'
+    except ImportError:
+        return HOME / '.hermes' / 'config.yaml'
+
+def get_config() -> dict:
+    """Return the cached config dict, loading from disk if needed."""
+    if not _cfg_cache:
+        reload_config()
+    return _cfg_cache
+
+def reload_config() -> None:
+    """Reload config.yaml from the active profile's directory."""
+    with _cfg_lock:
+        _cfg_cache.clear()
+        config_path = _get_config_path()
+        try:
+            import yaml as _yaml
+            if config_path.exists():
+                loaded = _yaml.safe_load(config_path.read_text())
+                if isinstance(loaded, dict):
+                    _cfg_cache.update(loaded)
+        except Exception:
+            pass
+
+# Initial load
+reload_config()
+cfg = _cfg_cache  # alias for backward compat with existing references
 
 # ── Default workspace discovery ───────────────────────────────────────────────
 def _discover_default_workspace() -> Path:
@@ -166,7 +208,7 @@ DEFAULT_WORKSPACE = _discover_default_workspace()
 DEFAULT_MODEL     = os.getenv('HERMES_WEBUI_DEFAULT_MODEL', 'openai/gpt-5.4-mini')
 
 # ── Startup diagnostics ───────────────────────────────────────────────────────
-def print_startup_config():
+def print_startup_config() -> None:
     """Print detected configuration at startup so the user can verify what was found."""
     ok   = '\033[32m[ok]\033[0m'
     warn = '\033[33m[!!]\033[0m'
@@ -182,7 +224,7 @@ def print_startup_config():
         f'  state dir   : {STATE_DIR}',
         f'  workspace   : {DEFAULT_WORKSPACE}',
         f'  host:port   : {HOST}:{PORT}',
-        f'  config file : {CONFIG_PATH}  {"(found)" if CONFIG_PATH.exists() else "(not found, using defaults)"}',
+        f'  config file : {_get_config_path()}  {"(found)" if _get_config_path().exists() else "(not found, using defaults)"}',
         '',
     ]
     print('\n'.join(lines), flush=True)
@@ -201,19 +243,23 @@ def print_startup_config():
             flush=True
         )
 
-def verify_hermes_imports():
+def verify_hermes_imports() -> tuple:
     """
     Attempt to import the key Hermes modules.
-    Returns (ok: bool, missing: list[str]).
+    Returns (ok: bool, missing: list[str], errors: dict[str, str]).
     """
     required = ['run_agent']
     missing  = []
+    errors   = {}
     for mod in required:
         try:
             __import__(mod)
-        except ImportError:
+        except Exception as e:
             missing.append(mod)
-    return (len(missing) == 0), missing
+            # Capture the full error message so startup logs show WHY
+            # (e.g. pydantic_core .so mismatch) instead of just the name.
+            errors[mod] = f"{type(e).__name__}: {e}"
+    return (len(missing) == 0), missing, errors
 
 # ── Limits ───────────────────────────────────────────────────────────────────
 MAX_FILE_BYTES   = 200_000
@@ -233,11 +279,12 @@ MIME_MAP = {
 }
 
 # ── Toolsets (from config.yaml or hardcoded default) ─────────────────────────
-CLI_TOOLSETS = cfg.get('platform_toolsets', {}).get('cli', [
+_DEFAULT_TOOLSETS = [
     'browser', 'clarify', 'code_execution', 'cronjob', 'delegation', 'file',
     'image_gen', 'memory', 'session_search', 'skills', 'terminal', 'todo',
     'web', 'webhook',
-])
+]
+CLI_TOOLSETS = get_config().get('platform_toolsets', {}).get('cli', _DEFAULT_TOOLSETS)
 
 # ── Model / provider discovery ───────────────────────────────────────────────
 
@@ -249,7 +296,7 @@ _FALLBACK_MODELS = [
     {'provider': 'OpenAI',    'id': 'openai/o4-mini',                   'label': 'o4-mini'},
     {'provider': 'Anthropic', 'id': 'anthropic/claude-sonnet-4.6',      'label': 'Claude Sonnet 4.6'},
     {'provider': 'Anthropic', 'id': 'anthropic/claude-sonnet-4-5',      'label': 'Claude Sonnet 4.5'},
-    {'provider': 'Anthropic', 'id': 'anthropic/claude-haiku-3-5',       'label': 'Claude Haiku 3.5'},
+    {'provider': 'Anthropic', 'id': 'anthropic/claude-haiku-4-5',       'label': 'Claude Haiku 4.5'},
     {'provider': 'Other',     'id': 'google/gemini-2.5-pro',            'label': 'Gemini 2.5 Pro'},
     {'provider': 'Other',     'id': 'deepseek/deepseek-chat-v3-0324',   'label': 'DeepSeek V3'},
     {'provider': 'Other',     'id': 'meta-llama/llama-4-scout',         'label': 'Llama 4 Scout'},
@@ -262,6 +309,7 @@ _PROVIDER_DISPLAY = {
     'zai': 'Z.AI / GLM', 'kimi-coding': 'Kimi / Moonshot', 'deepseek': 'DeepSeek',
     'minimax': 'MiniMax', 'google': 'Google', 'meta-llama': 'Meta Llama',
     'huggingface': 'HuggingFace', 'alibaba': 'Alibaba',
+    'ollama': 'Ollama', 'lmstudio': 'LM Studio',
 }
 
 # Well-known models per provider (used to populate dropdown for direct API providers)
@@ -270,7 +318,7 @@ _PROVIDER_MODELS = {
         {'id': 'claude-opus-4.6',    'label': 'Claude Opus 4.6'},
         {'id': 'claude-sonnet-4.6',  'label': 'Claude Sonnet 4.6'},
         {'id': 'claude-sonnet-4-5',  'label': 'Claude Sonnet 4.5'},
-        {'id': 'claude-haiku-3-5',   'label': 'Claude Haiku 3.5'},
+        {'id': 'claude-haiku-4-5',   'label': 'Claude Haiku 4.5'},
     ],
     'openai': [
         {'id': 'gpt-5.4-mini', 'label': 'GPT-5.4 Mini'},
@@ -295,9 +343,12 @@ _PROVIDER_MODELS = {
         {'id': 'gemini-2.5-pro',    'label': 'Gemini 2.5 Pro (via Nous)'},
     ],
     'zai': [
-        {'id': 'glm-4-plus',         'label': 'GLM-4 Plus'},
-        {'id': 'glm-4-air',          'label': 'GLM-4 Air'},
-        {'id': 'glm-z1-flash',       'label': 'GLM-Z1 Flash'},
+        {'id': 'glm-5.1',            'label': 'GLM-5.1'},
+        {'id': 'glm-5',              'label': 'GLM-5'},
+        {'id': 'glm-5-turbo',        'label': 'GLM-5 Turbo'},
+        {'id': 'glm-4.7',            'label': 'GLM-4.7'},
+        {'id': 'glm-4.5',            'label': 'GLM-4.5'},
+        {'id': 'glm-4.5-flash',      'label': 'GLM-4.5 Flash'},
     ],
     'kimi-coding': [
         {'id': 'moonshot-v1-8k',     'label': 'Moonshot v1 8k'},
@@ -306,12 +357,80 @@ _PROVIDER_MODELS = {
         {'id': 'kimi-latest',        'label': 'Kimi Latest'},
     ],
     'minimax': [
-        {'id': 'abab6.5s-chat',      'label': 'MiniMax ABAB 6.5S'},
-        {'id': 'abab6.5g-chat',      'label': 'MiniMax ABAB 6.5G'},
+        {'id': 'MiniMax-M2.7',           'label': 'MiniMax M2.7'},
+        {'id': 'MiniMax-M2.7-highspeed', 'label': 'MiniMax M2.7 Highspeed'},
+        {'id': 'MiniMax-M2.5',           'label': 'MiniMax M2.5'},
+        {'id': 'MiniMax-M2.5-highspeed', 'label': 'MiniMax M2.5 Highspeed'},
+        {'id': 'MiniMax-M2.1',           'label': 'MiniMax M2.1'},
+    ],
+    # GitHub Copilot — model IDs served via the Copilot API
+    'copilot': [
+        {'id': 'gpt-5.4',           'label': 'GPT-5.4'},
+        {'id': 'gpt-5.4-mini',      'label': 'GPT-5.4 Mini'},
+        {'id': 'gpt-4o',            'label': 'GPT-4o'},
+        {'id': 'claude-opus-4.6',   'label': 'Claude Opus 4.6'},
+        {'id': 'claude-sonnet-4.6', 'label': 'Claude Sonnet 4.6'},
+        {'id': 'gemini-2.5-pro',    'label': 'Gemini 2.5 Pro'},
+    ],
+    # 'gemini' is the hermes_cli provider ID for Google AI Studio
+    'gemini': [
+        {'id': 'gemini-2.5-pro',   'label': 'Gemini 2.5 Pro'},
+        {'id': 'gemini-2.0-flash', 'label': 'Gemini 2.0 Flash'},
     ],
 }
 
 
+def resolve_model_provider(model_id: str) -> tuple:
+    """Resolve model name, provider, and base_url for AIAgent.
+
+    Model IDs from the dropdown can be in several formats:
+      - 'claude-sonnet-4.6'          (bare name, uses config default provider)
+      - 'anthropic/claude-sonnet-4.6' (OpenRouter format, provider/model)
+      - '@minimax:MiniMax-M2.7'       (explicit provider hint from dropdown)
+
+    The @provider:model format is used for models from non-default provider
+    groups in the dropdown, so we can route them through the correct provider
+    via resolve_runtime_provider(requested=provider) instead of the default.
+
+    Returns (model, provider, base_url) where provider and base_url may be None.
+    """
+    config_provider = None
+    config_base_url = None
+    model_cfg = cfg.get('model', {})
+    if isinstance(model_cfg, dict):
+        config_provider = model_cfg.get('provider')
+        config_base_url = model_cfg.get('base_url')
+
+    model_id = (model_id or '').strip()
+    if not model_id:
+        return model_id, config_provider, config_base_url
+
+    # @provider:model format — explicit provider hint from the dropdown.
+    # Route through that provider directly (resolve_runtime_provider will
+    # resolve credentials in streaming.py).
+    if model_id.startswith('@') and ':' in model_id:
+        provider_hint, bare_model = model_id[1:].split(':', 1)
+        return bare_model, provider_hint, None
+
+    if '/' in model_id:
+        prefix, bare = model_id.split('/', 1)
+        # OpenRouter always needs the full provider/model path (e.g. openrouter/free,
+        # anthropic/claude-sonnet-4.6). Never strip the prefix for OpenRouter.
+        if config_provider == 'openrouter':
+            return model_id, 'openrouter', config_base_url
+        # If prefix matches config provider exactly, strip it and use that provider directly.
+        # e.g. config=anthropic, model=anthropic/claude-... → bare name to anthropic API
+        if config_provider and prefix == config_provider:
+            return bare, config_provider, config_base_url
+        # If prefix does NOT match config provider, the user picked a cross-provider model
+        # from the OpenRouter dropdown (e.g. config=anthropic but picked openai/gpt-5.4-mini).
+        # In this case always route through openrouter with the full provider/model string.
+        if prefix in _PROVIDER_MODELS and prefix != config_provider:
+            return model_id, 'openrouter', None
+
+    return model_id, config_provider, config_base_url
+
+
 def get_available_models() -> dict:
     """
     Return available models grouped by provider.
@@ -319,7 +438,8 @@ def get_available_models() -> dict:
     Discovery order:
       1. Read config.yaml 'model' section for active provider info
       2. Check for known API keys in env or ~/.hermes/.env
-      3. Fall back to hardcoded model list (OpenRouter-style)
+      3. Fetch models from custom endpoint if base_url is configured
+      4. Fall back to hardcoded model list (OpenRouter-style)
 
     Returns: {
         'active_provider': str|None,
@@ -332,12 +452,15 @@ def get_available_models() -> dict:
     groups = []
 
     # 1. Read config.yaml model section
+    cfg_base_url = ''  # must be defined before conditional blocks (#117)
     model_cfg = cfg.get('model', {})
+    cfg_base_url = ''
     if isinstance(model_cfg, str):
         default_model = model_cfg
     elif isinstance(model_cfg, dict):
         active_provider = model_cfg.get('provider')
         cfg_default = model_cfg.get('default', '')
+        cfg_base_url = model_cfg.get('base_url', '')
         if cfg_default:
             default_model = cfg_default
 
@@ -348,7 +471,11 @@ def get_available_models() -> dict:
 
     # 3. Try to read auth store for active provider (if hermes is installed)
     if not active_provider:
-        auth_store_path = HOME / '.hermes' / 'auth.json'
+        try:
+            from api.profiles import get_active_hermes_home as _gah
+            auth_store_path = _gah() / 'auth.json'
+        except ImportError:
+            auth_store_path = HOME / '.hermes' / 'auth.json'
         if auth_store_path.exists():
             try:
                 import json as _j
@@ -357,46 +484,142 @@ def get_available_models() -> dict:
             except Exception:
                 pass
 
-    # 4. Check for API keys that imply available providers
-    hermes_env_path = HOME / '.hermes' / '.env'
-    env_keys = {}
-    if hermes_env_path.exists():
-        try:
-            for line in hermes_env_path.read_text().splitlines():
-                line = line.strip()
-                if line and not line.startswith('#') and '=' in line:
-                    k, v = line.split('=', 1)
-                    env_keys[k.strip()] = v.strip().strip('"').strip("'")
-        except Exception:
-            pass
-
-    # Merge with actual env
-    all_env = {**env_keys}
-    for k in ('ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'OPENROUTER_API_KEY',
-              'GOOGLE_API_KEY', 'GLM_API_KEY', 'KIMI_API_KEY', 'DEEPSEEK_API_KEY'):
-        val = os.getenv(k)
-        if val:
-            all_env[k] = val
-
+    # 4. Detect available providers.
+    # Primary: ask hermes-agent's auth layer — the authoritative source. It checks
+    # auth.json, credential pools, and env vars the same way the agent does at runtime,
+    # so the dropdown reflects exactly what the user has configured.
+    # Fallback: scan raw API key env vars (matches old behaviour if hermes not available).
     detected_providers = set()
     if active_provider:
         detected_providers.add(active_provider)
-    if all_env.get('ANTHROPIC_API_KEY'):
-        detected_providers.add('anthropic')
-    if all_env.get('OPENAI_API_KEY'):
-        detected_providers.add('openai')
-    if all_env.get('OPENROUTER_API_KEY'):
-        detected_providers.add('openrouter')
-    if all_env.get('GOOGLE_API_KEY'):
-        detected_providers.add('google')
-    if all_env.get('GLM_API_KEY'):
-        detected_providers.add('zai')
-    if all_env.get('KIMI_API_KEY'):
-        detected_providers.add('kimi-coding')
-    if all_env.get('MINIMAX_API_KEY') or all_env.get('MINIMAX_CN_API_KEY'):
-        detected_providers.add('minimax')
-    if all_env.get('DEEPSEEK_API_KEY'):
-        detected_providers.add('deepseek')
+
+    _hermes_auth_used = False
+    try:
+        from hermes_cli.models import list_available_providers as _lap
+        from hermes_cli.auth import get_auth_status as _gas
+        for _p in _lap():
+            if not _p.get('authenticated'):
+                continue
+            # Exclude providers whose credential came from an ambient token
+            # (e.g. 'gh auth token' for Copilot on a machine with gh CLI auth).
+            # Only include providers with an explicit, dedicated credential.
+            try:
+                _src = _gas(_p['id']).get('key_source', '')
+                if _src == 'gh auth token':
+                    continue
+            except Exception:
+                pass
+            detected_providers.add(_p['id'])
+        _hermes_auth_used = True
+    except Exception:
+        pass
+
+    if not _hermes_auth_used:
+        # Fallback: scan .env and os.environ for known API key variables
+        try:
+            from api.profiles import get_active_hermes_home as _gah2
+            hermes_env_path = _gah2() / '.env'
+        except ImportError:
+            hermes_env_path = HOME / '.hermes' / '.env'
+        env_keys = {}
+        if hermes_env_path.exists():
+            try:
+                for line in hermes_env_path.read_text().splitlines():
+                    line = line.strip()
+                    if line and not line.startswith('#') and '=' in line:
+                        k, v = line.split('=', 1)
+                        env_keys[k.strip()] = v.strip().strip('"').strip("'")
+            except Exception:
+                pass
+        all_env = {**env_keys}
+        for k in ('ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'OPENROUTER_API_KEY',
+                  'GOOGLE_API_KEY', 'GLM_API_KEY', 'KIMI_API_KEY', 'DEEPSEEK_API_KEY'):
+            val = os.getenv(k)
+            if val:
+                all_env[k] = val
+        if all_env.get('ANTHROPIC_API_KEY'):
+            detected_providers.add('anthropic')
+        if all_env.get('OPENAI_API_KEY'):
+            detected_providers.add('openai')
+        if all_env.get('OPENROUTER_API_KEY'):
+            detected_providers.add('openrouter')
+        if all_env.get('GOOGLE_API_KEY'):
+            detected_providers.add('google')
+        if all_env.get('GLM_API_KEY'):
+            detected_providers.add('zai')
+        if all_env.get('KIMI_API_KEY'):
+            detected_providers.add('kimi-coding')
+        if all_env.get('MINIMAX_API_KEY') or all_env.get('MINIMAX_CN_API_KEY'):
+            detected_providers.add('minimax')
+        if all_env.get('DEEPSEEK_API_KEY'):
+            detected_providers.add('deepseek')
+
+    # 3. Fetch models from custom endpoint if base_url is configured
+    auto_detected_models = []
+    if cfg_base_url:
+        try:
+            import ipaddress
+            import urllib.request
+
+            # Normalize the base_url and build models endpoint
+            base_url = cfg_base_url.strip()
+            if base_url.endswith('/v1'):
+                endpoint_url = base_url[:-3] + '/models'
+            else:
+                endpoint_url = base_url + '/v1/models'
+
+            # Detect provider from base_url
+            provider = 'custom'
+            parsed = urlparse(base_url if '://' in base_url else f'http://{base_url}')
+            host = (parsed.netloc or parsed.path).lower()
+
+            if parsed.hostname:
+                try:
+                    addr = ipaddress.ip_address(parsed.hostname)
+                    if addr.is_private or addr.is_loopback or addr.is_link_local:
+                        if 'ollama' in host or '127.0.0.1' in host or 'localhost' in host:
+                            provider = 'ollama'
+                        elif 'lmstudio' in host or 'lm-studio' in host:
+                            provider = 'lmstudio'
+                        else:
+                            provider = 'local'
+                except ValueError:
+                    pass
+
+            # Resolve API key from environment
+            headers = {}
+            api_key_vars = ('HERMES_API_KEY', 'HERMES_OPENAI_API_KEY', 'OPENAI_API_KEY',
+                            'LOCAL_API_KEY', 'OPENROUTER_API_KEY', 'API_KEY')
+            for key in api_key_vars:
+                api_key = os.getenv(key)
+                if api_key:
+                    headers['Authorization'] = f'Bearer {api_key}'
+                    break
+
+            # Fetch model list from endpoint
+            req = urllib.request.Request(endpoint_url, method='GET')
+            for k, v in headers.items():
+                req.add_header(k, v)
+            with urllib.request.urlopen(req, timeout=10) as response:
+                data = json.loads(response.read().decode('utf-8'))
+
+            # Handle both OpenAI-compatible and llama.cpp response formats
+            models_list = []
+            if 'data' in data and isinstance(data['data'], list):
+                models_list = data['data']
+            elif 'models' in data and isinstance(data['models'], list):
+                models_list = data['models']
+
+            for model in models_list:
+                if not isinstance(model, dict):
+                    continue
+                model_id = model.get('id', '') or model.get('name', '') or model.get('model', '')
+                model_name = model.get('name', '') or model.get('model', '') or model_id
+                if model_id and model_name:
+                    auto_detected_models.append({'id': model_id, 'label': model_name})
+                    detected_providers.add(provider.lower())
+        except Exception:
+            pass  # custom endpoint unreachable or misconfigured -- fail silently
 
     # 5. Build model groups
     if detected_providers:
@@ -409,25 +632,68 @@ def get_available_models() -> dict:
                     'models': [{'id': m['id'], 'label': m['label']} for m in _FALLBACK_MODELS],
                 })
             elif pid in _PROVIDER_MODELS:
+                # For non-default providers, prefix model IDs with @provider:model
+                # so resolve_model_provider() routes through that specific provider
+                # via resolve_runtime_provider(requested=provider).
+                # The default provider's models keep bare names for direct API routing.
+                raw_models = _PROVIDER_MODELS[pid]
+                _active = (active_provider or '').lower()
+                if _active and pid != _active:
+                    models = []
+                    for m in raw_models:
+                        mid = m['id']
+                        # Don't double-prefix; use @provider: hint for bare names
+                        if mid.startswith('@') or '/' in mid:
+                            models.append({'id': mid, 'label': m['label']})
+                        else:
+                            models.append({'id': f'@{pid}:{mid}', 'label': m['label']})
+                else:
+                    models = list(raw_models)
                 groups.append({
                     'provider': provider_name,
-                    'models': _PROVIDER_MODELS[pid],
+                    'models': models,
                 })
             else:
-                # Unknown provider with key -- add a placeholder with the default model
-                groups.append({
-                    'provider': provider_name,
-                    'models': [{'id': default_model, 'label': default_model.split('/')[-1]}],
-                })
+                # Unknown provider -- use auto-detected models if available,
+                # otherwise fall back to default model placeholder
+                if auto_detected_models:
+                    groups.append({
+                        'provider': provider_name,
+                        'models': auto_detected_models,
+                    })
+                else:
+                    groups.append({
+                        'provider': provider_name,
+                        'models': [{'id': default_model, 'label': default_model.split('/')[-1]}],
+                    })
     else:
-        # No providers detected -- use fallback grouped list
-        by_provider = {}
-        for m in _FALLBACK_MODELS:
-            by_provider.setdefault(m['provider'], []).append(
-                {'id': m['id'], 'label': m['label']}
-            )
-        for provider_name, models in by_provider.items():
-            groups.append({'provider': provider_name, 'models': models})
+        # No providers detected. Show only the configured default model so the user
+        # can at least send messages with their current setting. Avoid showing a
+        # generic multi-provider list — those models wouldn't be routable anyway.
+        label = default_model.split('/')[-1] if '/' in default_model else default_model
+        groups.append({'provider': 'Default', 'models': [{'id': default_model, 'label': label}]})
+
+    # Ensure the user's configured default_model always appears in the dropdown.
+    # It may be missing if the model isn't in any hardcoded list (e.g. openrouter/free,
+    # a custom local model, or any model.default not in _FALLBACK_MODELS).
+    # Normalize before comparing: strip provider prefix so 'anthropic/claude-opus-4.6'
+    # matches 'claude-opus-4.6' already in the list and avoids a duplicate entry.
+    if default_model:
+        _norm = lambda mid: mid.split('/', 1)[-1] if '/' in mid else mid
+        all_ids_norm = {_norm(m['id']) for g in groups for m in g.get('models', [])}
+        if _norm(default_model) not in all_ids_norm:
+            # Determine which group to inject into
+            label = default_model.split('/')[-1] if '/' in default_model else default_model
+            injected = False
+            for g in groups:
+                if active_provider and active_provider.lower() in g.get('provider', '').lower():
+                    g['models'].insert(0, {'id': default_model, 'label': label})
+                    injected = True
+                    break
+            if not injected and groups:
+                groups[0]['models'].insert(0, {'id': default_model, 'label': label})
+            elif not groups:
+                groups.append({'provider': active_provider or 'Default', 'models': [{'id': default_model, 'label': label}]})
 
     return {
         'active_provider': active_provider,
@@ -472,6 +738,14 @@ def _get_session_agent_lock(session_id: str) -> threading.Lock:
 _SETTINGS_DEFAULTS = {
     'default_model': DEFAULT_MODEL,
     'default_workspace': str(DEFAULT_WORKSPACE),
+    'send_key': 'enter',  # 'enter' or 'ctrl+enter'
+    'show_token_usage': False,  # show input/output token badge below assistant messages
+    'show_cli_sessions': False,  # merge CLI sessions from state.db into the sidebar
+    'sync_to_insights': False,  # mirror WebUI token usage to state.db for /insights
+    'check_for_updates': True,  # check if webui/agent repos are behind upstream
+    'theme': 'dark',  # active UI theme name (no enum gate -- allows custom themes)
+    'bot_name': os.getenv('HERMES_WEBUI_BOT_NAME', 'Hermes'),  # display name for the assistant
+    'password_hash': None,  # SHA-256 hash; None = auth disabled
 }
 
 def load_settings() -> dict:
@@ -486,13 +760,32 @@ def load_settings() -> dict:
             pass
     return settings
 
-_SETTINGS_ALLOWED_KEYS = set(_SETTINGS_DEFAULTS.keys())
+_SETTINGS_ALLOWED_KEYS = set(_SETTINGS_DEFAULTS.keys()) - {'password_hash'}
+_SETTINGS_ENUM_VALUES = {
+    'send_key': {'enter', 'ctrl+enter'},
+}
+_SETTINGS_BOOL_KEYS = {'show_token_usage', 'show_cli_sessions', 'sync_to_insights', 'check_for_updates'}
 
 def save_settings(settings: dict) -> dict:
     """Save settings to disk. Returns the merged settings. Ignores unknown keys."""
+    import hashlib as _hl
     current = load_settings()
+    # Handle _set_password: hash and store as password_hash
+    raw_pw = settings.pop('_set_password', None)
+    if raw_pw and isinstance(raw_pw, str) and raw_pw.strip():
+        salt = str(STATE_DIR).encode()
+        current['password_hash'] = _hl.sha256(salt + raw_pw.strip().encode()).hexdigest()
+    # Handle _clear_password: explicitly disable auth
+    if settings.pop('_clear_password', False):
+        current['password_hash'] = None
     for k, v in settings.items():
         if k in _SETTINGS_ALLOWED_KEYS:
+            # Validate enum-constrained keys
+            if k in _SETTINGS_ENUM_VALUES and v not in _SETTINGS_ENUM_VALUES[k]:
+                continue
+            # Coerce bool keys
+            if k in _SETTINGS_BOOL_KEYS:
+                v = bool(v)
             current[k] = v
     SETTINGS_FILE.write_text(
         json.dumps(current, ensure_ascii=False, indent=2),
@@ -516,3 +809,11 @@ if SETTINGS_FILE.exists():
 
 # ── SESSIONS in-memory cache (LRU OrderedDict) ───────────────────────────────
 SESSIONS: collections.OrderedDict = collections.OrderedDict()
+
+# ── Profile state initialisation ────────────────────────────────────────────
+# Must run after all imports are resolved to correctly patch module-level caches
+try:
+    from api.profiles import init_profile_state
+    init_profile_state()
+except ImportError:
+    pass  # hermes_cli not available -- default profile only

api/helpers.py

@@ -6,14 +6,14 @@ from pathlib import Path
 from api.config import IMAGE_EXTS, MD_EXTS
 
 
-def require(body: dict, *fields):
+def require(body: dict, *fields) -> None:
     """Phase D: Validate required fields. Raises ValueError with clean message."""
     missing = [f for f in fields if not body.get(f) and body.get(f) != 0]
     if missing:
         raise ValueError(f"Missing required field(s): {', '.join(missing)}")
 
 
-def bad(handler, msg, status=400):
+def bad(handler, msg, status: int=400):
     """Return a clean JSON error response."""
     return j(handler, {'error': msg}, status=status)
 
@@ -25,31 +25,45 @@ def safe_resolve(root: Path, requested: str) -> Path:
     return resolved
 
 
-def j(handler, payload, status=200):
+def _security_headers(handler):
+    """Add security headers to every response."""
+    handler.send_header('X-Content-Type-Options', 'nosniff')
+    handler.send_header('X-Frame-Options', 'DENY')
+    handler.send_header('Referrer-Policy', 'same-origin')
+
+
+def j(handler, payload, status: int=200) -> None:
     """Send a JSON response."""
     body = _json.dumps(payload, ensure_ascii=False, indent=2).encode('utf-8')
     handler.send_response(status)
     handler.send_header('Content-Type', 'application/json; charset=utf-8')
     handler.send_header('Content-Length', str(len(body)))
     handler.send_header('Cache-Control', 'no-store')
+    _security_headers(handler)
     handler.end_headers()
     handler.wfile.write(body)
 
 
-def t(handler, payload, status=200, content_type='text/plain; charset=utf-8'):
+def t(handler, payload, status: int=200, content_type: str='text/plain; charset=utf-8') -> None:
     """Send a plain text or HTML response."""
     body = payload if isinstance(payload, bytes) else str(payload).encode('utf-8')
     handler.send_response(status)
     handler.send_header('Content-Type', content_type)
     handler.send_header('Content-Length', str(len(body)))
     handler.send_header('Cache-Control', 'no-store')
+    _security_headers(handler)
     handler.end_headers()
     handler.wfile.write(body)
 
 
-def read_body(handler):
-    """Read and JSON-parse a POST request body."""
+MAX_BODY_BYTES = 20 * 1024 * 1024  # 20MB limit for non-upload POST bodies
+
+
+def read_body(handler) -> dict:
+    """Read and JSON-parse a POST request body (capped at 20MB)."""
     length = int(handler.headers.get('Content-Length', 0))
+    if length > MAX_BODY_BYTES:
+        raise ValueError(f'Request body too large ({length} bytes, max {MAX_BODY_BYTES})')
     raw = handler.rfile.read(length) if length else b'{}'
     try:
         return _json.loads(raw)

api/models.py

@@ -10,7 +10,7 @@ from pathlib import Path
 import api.config as _cfg
 from api.config import (
     SESSION_DIR, SESSION_INDEX_FILE, SESSIONS, SESSIONS_MAX,
-    LOCK, DEFAULT_WORKSPACE, DEFAULT_MODEL
+    LOCK, DEFAULT_WORKSPACE, DEFAULT_MODEL, PROJECTS_FILE, HOME
 )
 from api.workspace import get_last_workspace
 
@@ -34,17 +34,68 @@ def _write_session_index():
 
 
 class Session:
-    def __init__(self, session_id=None, title='Untitled', workspace=str(DEFAULT_WORKSPACE), model=DEFAULT_MODEL, messages=None, created_at=None, updated_at=None, tool_calls=None, pinned=False, archived=False, **kwargs):
-        self.session_id = session_id or uuid.uuid4().hex[:12]; self.title = title; self.workspace = str(Path(workspace).expanduser().resolve()); self.model = model; self.messages = messages or []; self.tool_calls = tool_calls or []; self.created_at = created_at or time.time(); self.updated_at = updated_at or time.time(); self.pinned = bool(pinned); self.archived = bool(archived)
+    def __init__(self, session_id: str=None, title: str='Untitled',
+                 workspace=str(DEFAULT_WORKSPACE), model=DEFAULT_MODEL,
+                 messages=None, created_at=None, updated_at=None,
+                 tool_calls=None, pinned: bool=False, archived: bool=False,
+                 project_id: str=None, profile=None,
+                 input_tokens: int=0, output_tokens: int=0, estimated_cost=None,
+                 personality=None,
+                 **kwargs):
+        self.session_id = session_id or uuid.uuid4().hex[:12]
+        self.title = title
+        self.workspace = str(Path(workspace).expanduser().resolve())
+        self.model = model
+        self.messages = messages or []
+        self.tool_calls = tool_calls or []
+        self.created_at = created_at or time.time()
+        self.updated_at = updated_at or time.time()
+        self.pinned = bool(pinned)
+        self.archived = bool(archived)
+        self.project_id = project_id or None
+        self.profile = profile
+        self.input_tokens = input_tokens or 0
+        self.output_tokens = output_tokens or 0
+        self.estimated_cost = estimated_cost
+        self.personality = personality
+
     @property
-    def path(self): return SESSION_DIR / f'{self.session_id}.json'
-    def save(self): self.updated_at = time.time(); self.path.write_text(json.dumps(self.__dict__, ensure_ascii=False, indent=2), encoding='utf-8'); _write_session_index()
+    def path(self):
+        return SESSION_DIR / f'{self.session_id}.json'
+
+    def save(self) -> None:
+        self.updated_at = time.time()
+        self.path.write_text(
+            json.dumps(self.__dict__, ensure_ascii=False, indent=2),
+            encoding='utf-8',
+        )
+        _write_session_index()
+
     @classmethod
     def load(cls, sid):
         p = SESSION_DIR / f'{sid}.json'
-        if not p.exists(): return None
+        if not p.exists():
+            return None
         return cls(**json.loads(p.read_text(encoding='utf-8')))
-    def compact(self): return {'session_id': self.session_id, 'title': self.title, 'workspace': self.workspace, 'model': self.model, 'message_count': len(self.messages), 'created_at': self.created_at, 'updated_at': self.updated_at, 'pinned': self.pinned, 'archived': self.archived}
+
+    def compact(self) -> dict:
+        return {
+            'session_id': self.session_id,
+            'title': self.title,
+            'workspace': self.workspace,
+            'model': self.model,
+            'message_count': len(self.messages),
+            'created_at': self.created_at,
+            'updated_at': self.updated_at,
+            'pinned': self.pinned,
+            'archived': self.archived,
+            'project_id': self.project_id,
+            'profile': self.profile,
+            'input_tokens': self.input_tokens,
+            'output_tokens': self.output_tokens,
+            'estimated_cost': self.estimated_cost,
+            'personality': self.personality,
+        }
 
 def get_session(sid):
     with LOCK:
@@ -63,7 +114,12 @@ def get_session(sid):
 
 def new_session(workspace=None, model=None):
     # Use _cfg.DEFAULT_MODEL (not the import-time snapshot) so save_settings() changes take effect
-    s = Session(workspace=workspace or get_last_workspace(), model=model or _cfg.DEFAULT_MODEL)
+    try:
+        from api.profiles import get_active_profile_name
+        _profile = get_active_profile_name()
+    except ImportError:
+        _profile = None
+    s = Session(workspace=workspace or get_last_workspace(), model=model or _cfg.DEFAULT_MODEL, profile=_profile)
     with LOCK:
         SESSIONS[s.session_id] = s
         SESSIONS.move_to_end(s.session_id)
@@ -85,6 +141,11 @@ def all_sessions():
             result = sorted(index_map.values(), key=lambda s: (s.get('pinned', False), s['updated_at']), reverse=True)
             # Hide empty Untitled sessions from the UI (created by tests, page refreshes, etc.)
             result = [s for s in result if not (s.get('title','Untitled')=='Untitled' and s.get('message_count',0)==0)]
+            # Backfill: sessions created before Sprint 22 have no profile tag.
+            # Attribute them to 'default' so the client profile filter works correctly.
+            for s in result:
+                if not s.get('profile'):
+                    s['profile'] = 'default'
             return result
         except Exception:
             pass  # fall through to full scan
@@ -100,10 +161,14 @@ def all_sessions():
     for s in SESSIONS.values():
         if all(s.session_id != x.session_id for x in out): out.append(s)
     out.sort(key=lambda s: (getattr(s, 'pinned', False), s.updated_at), reverse=True)
-    return [s.compact() for s in out if not (s.title=='Untitled' and len(s.messages)==0)]
+    result = [s.compact() for s in out if not (s.title=='Untitled' and len(s.messages)==0)]
+    for s in result:
+        if not s.get('profile'):
+            s['profile'] = 'default'
+    return result
 
 
-def title_from(messages, fallback='Untitled'):
+def title_from(messages, fallback: str='Untitled'):
     """Derive a session title from the first user message."""
     for m in messages:
         if m.get('role') == 'user':
@@ -114,3 +179,193 @@ def title_from(messages, fallback='Untitled'):
             if text:
                 return text[:64]
     return fallback
+
+
+# ── Project helpers ──────────────────────────────────────────────────────────
+
+def load_projects() -> list:
+    """Load project list from disk. Returns list of project dicts."""
+    if not PROJECTS_FILE.exists():
+        return []
+    try:
+        return json.loads(PROJECTS_FILE.read_text(encoding='utf-8'))
+    except Exception:
+        return []
+
+def save_projects(projects) -> None:
+    """Write project list to disk."""
+    PROJECTS_FILE.write_text(json.dumps(projects, ensure_ascii=False, indent=2), encoding='utf-8')
+
+
+def import_cli_session(session_id: str, title: str, messages, model: str='unknown', profile=None):
+    """Create a new WebUI session populated with CLI messages.
+    Returns the Session object.
+    """
+    s = Session(
+        session_id=session_id,
+        title=title,
+        workspace=get_last_workspace(),
+        model=model,
+        messages=messages,
+        profile=profile,
+    )
+    s.save()
+    return s
+
+
+# ── CLI session bridge ──────────────────────────────────────────────────────
+
+def get_cli_sessions() -> list:
+    """Read CLI sessions from the agent's SQLite store and return them as
+    dicts in a format the WebUI sidebar can render alongside local sessions.
+
+    Returns empty list if the SQLite DB is missing, the sqlite3 module is
+    unavailable, or any error occurs -- the bridge is purely additive and never
+    crashes the WebUI.
+    """
+    import os
+    cli_sessions = []
+    try:
+        import sqlite3
+    except ImportError:
+        return cli_sessions
+
+    # Use the active WebUI profile's HERMES_HOME to find state.db.
+    # The active profile is determined by what the user has selected in the UI
+    # (stored in the server's runtime config). This means:
+    #   - default profile  -> ~/.hermes/state.db
+    #   - named profile X  -> ~/.hermes/profiles/X/state.db
+    # We resolve the active profile's home directory rather than just using
+    # HERMES_HOME (which is the server's launch profile, not necessarily the
+    # active one after a profile switch).
+    try:
+        from api.profiles import get_active_hermes_home
+        hermes_home = Path(get_active_hermes_home()).expanduser().resolve()
+    except Exception:
+        hermes_home = Path(os.getenv('HERMES_HOME', str(HOME / '.hermes'))).expanduser().resolve()
+
+    db_path = hermes_home / 'state.db'
+    if not db_path.exists():
+        return cli_sessions
+
+    # Try to resolve the active CLI profile so imported sessions integrate
+    # with the WebUI profile filter (available since Sprint 22).
+    try:
+        from api.profiles import get_active_profile_name
+        _cli_profile = get_active_profile_name()
+    except ImportError:
+        _cli_profile = None  # older agent -- fall back to no profile
+
+    try:
+        with sqlite3.connect(str(db_path)) as conn:
+            conn.row_factory = sqlite3.Row
+            cur = conn.cursor()
+            cur.execute("""
+                SELECT s.id, s.title, s.model, s.message_count,
+                       s.started_at, s.source,
+                       MAX(m.timestamp) AS last_activity
+                FROM sessions s
+                LEFT JOIN messages m ON m.session_id = s.id
+                GROUP BY s.id
+                ORDER BY COALESCE(MAX(m.timestamp), s.started_at) DESC
+                LIMIT 200
+            """)
+            for row in cur.fetchall():
+                sid = row['id']
+                raw_ts = row['last_activity'] or row['started_at']
+                # Prefer the CLI session's own profile from the DB; fall back to
+                # the active CLI profile so sidebar filtering works either way.
+                profile = _cli_profile  # CLI DB has no profile column; use active profile
+
+                cli_sessions.append({
+                    'session_id': sid,
+                    'title': row['title'] or 'CLI Session',
+                    'workspace': str(get_last_workspace()),
+                    'model': row['model'] or 'unknown',
+                    'message_count': row['message_count'] or 0,
+                    'created_at': row['started_at'],
+                    'updated_at': raw_ts,
+                    'pinned': False,
+                    'archived': False,
+                    'project_id': None,
+                    'profile': profile,
+                    'source_tag': 'cli',
+                    'is_cli_session': True,
+                })
+    except Exception:
+        # DB schema changed, locked, or corrupted -- silently degrade
+        return []
+
+    return cli_sessions
+
+
+def get_cli_session_messages(sid) -> list:
+    """Read messages for a single CLI session from the SQLite store.
+    Returns a list of {role, content, timestamp} dicts.
+    Returns empty list on any error.
+    """
+    import os
+    try:
+        import sqlite3
+    except ImportError:
+        return []
+
+    try:
+        from api.profiles import get_active_hermes_home
+        hermes_home = Path(get_active_hermes_home()).expanduser().resolve()
+    except Exception:
+        hermes_home = Path(os.getenv('HERMES_HOME', str(HOME / '.hermes'))).expanduser().resolve()
+    db_path = hermes_home / 'state.db'
+    if not db_path.exists():
+        return []
+
+    try:
+        with sqlite3.connect(str(db_path)) as conn:
+            conn.row_factory = sqlite3.Row
+            cur = conn.cursor()
+            cur.execute("""
+                SELECT role, content, timestamp
+                FROM messages
+                WHERE session_id = ?
+                ORDER BY timestamp ASC
+            """, (sid,))
+            msgs = []
+            for row in cur.fetchall():
+                msgs.append({
+                    'role': row['role'],
+                    'content': row['content'],
+                    'timestamp': row['timestamp'],
+                })
+    except Exception:
+        return []
+    return msgs
+
+
+def delete_cli_session(sid) -> bool:
+    """Delete a CLI session from state.db (messages + session row).
+    Returns True if deleted, False if not found or error.
+    """
+    import os
+    try:
+        import sqlite3
+    except ImportError:
+        return False
+
+    try:
+        from api.profiles import get_active_hermes_home
+        hermes_home = Path(get_active_hermes_home()).expanduser().resolve()
+    except Exception:
+        hermes_home = Path(os.getenv('HERMES_HOME', str(HOME / '.hermes'))).expanduser().resolve()
+    db_path = hermes_home / 'state.db'
+    if not db_path.exists():
+        return False
+
+    try:
+        with sqlite3.connect(str(db_path)) as conn:
+            cur = conn.cursor()
+            cur.execute("DELETE FROM messages WHERE session_id = ?", (sid,))
+            cur.execute("DELETE FROM sessions WHERE id = ?", (sid,))
+            conn.commit()
+            return cur.rowcount > 0
+    except Exception:
+        return False

api/profiles.py

@@ -0,0 +1,366 @@
+"""
+Hermes Web UI -- Profile state management.
+Wraps hermes_cli.profiles to provide profile switching for the web UI.
+
+The web UI maintains a process-level "active profile" that determines which
+HERMES_HOME directory is used for config, skills, memory, cron, and API keys.
+Profile switches update os.environ['HERMES_HOME'] and monkey-patch module-level
+cached paths in hermes-agent modules (skills_tool, cron/jobs) that snapshot
+HERMES_HOME at import time.
+"""
+import json
+import os
+import re
+import shutil
+import threading
+from pathlib import Path
+
+# ── Constants (match hermes_cli.profiles upstream) ─────────────────────────
+_PROFILE_ID_RE = re.compile(r'^[a-z0-9][a-z0-9_-]{0,63}$')
+_PROFILE_DIRS = [
+    'memories', 'sessions', 'skills', 'skins',
+    'logs', 'plans', 'workspace', 'cron',
+]
+_CLONE_CONFIG_FILES = ['config.yaml', '.env', 'SOUL.md']
+
+# ── Module state ────────────────────────────────────────────────────────────
+_active_profile = 'default'
+_profile_lock = threading.Lock()
+
+def _resolve_base_hermes_home() -> Path:
+    """Return the BASE ~/.hermes directory — the root that contains profiles/.
+
+    This is intentionally distinct from HERMES_HOME, which tracks the *active
+    profile's* home and changes on every profile switch.  The base dir must
+    always point to the top-level .hermes regardless of which profile is active.
+
+    Resolution order:
+      1. HERMES_BASE_HOME env var (set explicitly, highest priority)
+      2. HERMES_HOME env var — but only if it does NOT look like a profile subdir
+         (i.e. its parent is not named 'profiles').  This handles test isolation
+         where HERMES_HOME is set to an isolated test state dir.
+      3. ~/.hermes (always-correct default)
+
+    The bug this prevents: if HERMES_HOME has already been mutated to
+    /home/user/.hermes/profiles/webui (by init_profile_state at startup),
+    reading it here would make _DEFAULT_HERMES_HOME point to that subdir,
+    causing switch_profile('webui') to look for
+    /home/user/.hermes/profiles/webui/profiles/webui — which doesn't exist.
+    """
+    # Explicit override for tests or unusual setups
+    base_override = os.getenv('HERMES_BASE_HOME', '').strip()
+    if base_override:
+        return Path(base_override).expanduser()
+
+    hermes_home = os.getenv('HERMES_HOME', '').strip()
+    if hermes_home:
+        p = Path(hermes_home).expanduser()
+        # If HERMES_HOME points to a profiles/ subdir, walk up two levels to the base
+        if p.parent.name == 'profiles':
+            return p.parent.parent
+        # Otherwise trust it (e.g. test isolation sets HERMES_HOME to TEST_STATE_DIR)
+        return p
+
+    return Path.home() / '.hermes'
+
+_DEFAULT_HERMES_HOME = _resolve_base_hermes_home()
+
+
+def _read_active_profile_file() -> str:
+    """Read the sticky active profile from ~/.hermes/active_profile."""
+    ap_file = _DEFAULT_HERMES_HOME / 'active_profile'
+    if ap_file.exists():
+        try:
+            name = ap_file.read_text().strip()
+            if name:
+                return name
+        except Exception:
+            pass
+    return 'default'
+
+
+# ── Public API ──────────────────────────────────────────────────────────────
+
+def get_active_profile_name() -> str:
+    """Return the currently active profile name."""
+    return _active_profile
+
+
+def get_active_hermes_home() -> Path:
+    """Return the HERMES_HOME path for the currently active profile."""
+    if _active_profile == 'default':
+        return _DEFAULT_HERMES_HOME
+    profile_dir = _DEFAULT_HERMES_HOME / 'profiles' / _active_profile
+    if profile_dir.is_dir():
+        return profile_dir
+    return _DEFAULT_HERMES_HOME
+
+
+def _set_hermes_home(home: Path):
+    """Set HERMES_HOME env var and monkey-patch cached module-level paths."""
+    os.environ['HERMES_HOME'] = str(home)
+
+    # Patch skills_tool module-level cache (snapshots HERMES_HOME at import)
+    try:
+        import tools.skills_tool as _sk
+        _sk.HERMES_HOME = home
+        _sk.SKILLS_DIR = home / 'skills'
+    except (ImportError, AttributeError):
+        pass
+
+    # Patch cron/jobs module-level cache
+    try:
+        import cron.jobs as _cj
+        _cj.HERMES_DIR = home
+        _cj.CRON_DIR = home / 'cron'
+        _cj.JOBS_FILE = _cj.CRON_DIR / 'jobs.json'
+        _cj.OUTPUT_DIR = _cj.CRON_DIR / 'output'
+    except (ImportError, AttributeError):
+        pass
+
+
+def _reload_dotenv(home: Path):
+    """Load .env from the profile dir into os.environ (additive)."""
+    env_path = home / '.env'
+    if not env_path.exists():
+        return
+    try:
+        for line in env_path.read_text().splitlines():
+            line = line.strip()
+            if line and not line.startswith('#') and '=' in line:
+                k, v = line.split('=', 1)
+                k = k.strip()
+                v = v.strip().strip('"').strip("'")
+                if k and v:
+                    os.environ[k] = v
+    except Exception:
+        pass
+
+
+def init_profile_state() -> None:
+    """Initialize profile state at server startup.
+
+    Reads ~/.hermes/active_profile, sets HERMES_HOME env var, patches
+    module-level cached paths.  Called once from config.py after imports.
+    """
+    global _active_profile
+    _active_profile = _read_active_profile_file()
+    home = get_active_hermes_home()
+    _set_hermes_home(home)
+    _reload_dotenv(home)
+
+
+def switch_profile(name: str) -> dict:
+    """Switch the active profile.
+
+    Validates the profile exists, updates process state, patches module caches,
+    reloads .env, and reloads config.yaml.
+
+    Returns: {'profiles': [...], 'active': name}
+    Raises ValueError if profile doesn't exist or agent is busy.
+    """
+    global _active_profile
+
+    # Import here to avoid circular import at module load
+    from api.config import STREAMS, STREAMS_LOCK, reload_config
+
+    # Block if agent is running
+    with STREAMS_LOCK:
+        if len(STREAMS) > 0:
+            raise RuntimeError(
+                'Cannot switch profiles while an agent is running. '
+                'Cancel or wait for it to finish.'
+            )
+
+    # Resolve profile directory
+    if name == 'default':
+        home = _DEFAULT_HERMES_HOME
+    else:
+        home = _DEFAULT_HERMES_HOME / 'profiles' / name
+        if not home.is_dir():
+            raise ValueError(f"Profile '{name}' does not exist.")
+
+    with _profile_lock:
+        _active_profile = name
+        _set_hermes_home(home)
+        _reload_dotenv(home)
+
+    # Write sticky default for CLI consistency
+    try:
+        ap_file = _DEFAULT_HERMES_HOME / 'active_profile'
+        ap_file.write_text(name if name != 'default' else '')
+    except Exception:
+        pass
+
+    # Reload config.yaml from the new profile
+    reload_config()
+
+    # Return profile-specific defaults so frontend can apply them
+    from api.workspace import get_last_workspace
+    from api.config import get_config
+    cfg = get_config()
+    model_cfg = cfg.get('model', {})
+    default_model = None
+    if isinstance(model_cfg, str):
+        default_model = model_cfg
+    elif isinstance(model_cfg, dict):
+        default_model = model_cfg.get('default')
+
+    return {
+        'profiles': list_profiles_api(),
+        'active': name,
+        'default_model': default_model,
+        'default_workspace': get_last_workspace(),
+    }
+
+
+def list_profiles_api() -> list:
+    """List all profiles with metadata, serialized for JSON response."""
+    try:
+        from hermes_cli.profiles import list_profiles
+        infos = list_profiles()
+    except ImportError:
+        # hermes_cli not available -- return just the default
+        return [_default_profile_dict()]
+
+    active = _active_profile
+    result = []
+    for p in infos:
+        result.append({
+            'name': p.name,
+            'path': str(p.path),
+            'is_default': p.is_default,
+            'is_active': p.name == active,
+            'gateway_running': p.gateway_running,
+            'model': p.model,
+            'provider': p.provider,
+            'has_env': p.has_env,
+            'skill_count': p.skill_count,
+        })
+    return result
+
+
+def _default_profile_dict() -> dict:
+    """Fallback profile dict when hermes_cli is not importable."""
+    return {
+        'name': 'default',
+        'path': str(_DEFAULT_HERMES_HOME),
+        'is_default': True,
+        'is_active': True,
+        'gateway_running': False,
+        'model': None,
+        'provider': None,
+        'has_env': (_DEFAULT_HERMES_HOME / '.env').exists(),
+        'skill_count': 0,
+    }
+
+
+def _validate_profile_name(name: str):
+    """Validate profile name format (matches hermes_cli.profiles upstream)."""
+    if name == 'default':
+        raise ValueError("Cannot create a profile named 'default' -- it is the built-in profile.")
+    # Use fullmatch (not match) so a trailing newline can't sneak past the $ anchor
+    if not _PROFILE_ID_RE.fullmatch(name):
+        raise ValueError(
+            f"Invalid profile name {name!r}. "
+            "Must match [a-z0-9][a-z0-9_-]{0,63}"
+        )
+
+
+def _create_profile_fallback(name: str, clone_from: str = None,
+                              clone_config: bool = False) -> Path:
+    """Create a profile directory without hermes_cli (Docker/standalone fallback)."""
+    profile_dir = _DEFAULT_HERMES_HOME / 'profiles' / name
+    if profile_dir.exists():
+        raise FileExistsError(f"Profile '{name}' already exists.")
+
+    # Bootstrap directory structure (exist_ok=False so a concurrent create raises)
+    profile_dir.mkdir(parents=True, exist_ok=False)
+    for subdir in _PROFILE_DIRS:
+        (profile_dir / subdir).mkdir(parents=True, exist_ok=True)
+
+    # Clone config files from source profile if requested
+    if clone_config and clone_from:
+        if clone_from == 'default':
+            source_dir = _DEFAULT_HERMES_HOME
+        else:
+            source_dir = _DEFAULT_HERMES_HOME / 'profiles' / clone_from
+        if source_dir.is_dir():
+            for filename in _CLONE_CONFIG_FILES:
+                src = source_dir / filename
+                if src.exists():
+                    shutil.copy2(src, profile_dir / filename)
+
+    return profile_dir
+
+
+def create_profile_api(name: str, clone_from: str = None,
+                       clone_config: bool = False) -> dict:
+    """Create a new profile. Returns the new profile info dict."""
+    _validate_profile_name(name)
+    # Defense-in-depth: validate clone_from here too, even though routes.py
+    # also validates it. Any caller that bypasses the HTTP layer gets protection.
+    if clone_from is not None and clone_from != 'default':
+        _validate_profile_name(clone_from)
+
+    try:
+        from hermes_cli.profiles import create_profile
+        create_profile(
+            name,
+            clone_from=clone_from,
+            clone_config=clone_config,
+            clone_all=False,
+            no_alias=True,
+        )
+    except ImportError:
+        _create_profile_fallback(name, clone_from, clone_config)
+
+    # Find and return the newly created profile info.
+    # When hermes_cli is not importable, list_profiles_api() also falls back
+    # to the stub default-only list and won't find the new profile by name.
+    # In that case, return a complete profile dict directly.
+    profile_path = _DEFAULT_HERMES_HOME / 'profiles' / name
+    for p in list_profiles_api():
+        if p['name'] == name:
+            return p
+    return {
+        'name': name,
+        'path': str(profile_path),
+        'is_default': False,
+        'is_active': _active_profile == name,
+        'gateway_running': False,
+        'model': None,
+        'provider': None,
+        'has_env': (profile_path / '.env').exists(),
+        'skill_count': 0,
+    }
+
+
+def delete_profile_api(name: str) -> dict:
+    """Delete a profile. Switches to default first if it's the active one."""
+    if name == 'default':
+        raise ValueError("Cannot delete the default profile.")
+
+    # If deleting the active profile, switch to default first
+    if _active_profile == name:
+        try:
+            switch_profile('default')
+        except RuntimeError:
+            raise RuntimeError(
+                f"Cannot delete active profile '{name}' while an agent is running. "
+                "Cancel or wait for it to finish."
+            )
+
+    try:
+        from hermes_cli.profiles import delete_profile
+        delete_profile(name, yes=True)
+    except ImportError:
+        # Manual fallback: just remove the directory
+        import shutil
+        profile_dir = _DEFAULT_HERMES_HOME / 'profiles' / name
+        if profile_dir.is_dir():
+            shutil.rmtree(str(profile_dir))
+        else:
+            raise ValueError(f"Profile '{name}' does not exist.")
+
+    return {'ok': True, 'name': name}

api/routes.py

@@ -2,6 +2,7 @@
 Hermes Web UI -- Route handlers for GET and POST endpoints.
 Extracted from server.py (Sprint 11) so server.py is a thin shell.
 """
+import html as _html
 import json
 import os
 import queue
@@ -19,10 +20,12 @@ from api.config import (
     IMAGE_EXTS, MD_EXTS, MIME_MAP, MAX_FILE_BYTES, MAX_UPLOAD_BYTES,
     CHAT_LOCK, load_settings, save_settings,
 )
-from api.helpers import require, bad, safe_resolve, j, t, read_body
+from api.helpers import require, bad, safe_resolve, j, t, read_body, _security_headers
 from api.models import (
     Session, get_session, new_session, all_sessions, title_from,
     _write_session_index, SESSION_INDEX_FILE,
+    load_projects, save_projects, import_cli_session,
+    get_cli_sessions, get_cli_session_messages,
 )
 from api.workspace import (
     load_workspaces, save_workspaces, get_last_workspace, set_last_workspace,
@@ -51,15 +54,81 @@ except ImportError:
     _permanent_approved = set()
 
 
+# ── Login page (self-contained, no external deps) ────────────────────────────
+_LOGIN_PAGE_HTML = '''<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>{{BOT_NAME}} — Sign in</title>
+<style>
+*{box-sizing:border-box;margin:0;padding:0}
+body{background:#1a1a2e;color:#e8e8f0;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",system-ui,sans-serif;
+  height:100vh;display:flex;align-items:center;justify-content:center}
+.card{background:#16213e;border:1px solid rgba(255,255,255,.08);border-radius:16px;padding:36px 32px;
+  width:320px;text-align:center;box-shadow:0 8px 32px rgba(0,0,0,.3)}
+.logo{width:48px;height:48px;border-radius:12px;background:linear-gradient(145deg,#e8a030,#e94560);
+  display:flex;align-items:center;justify-content:center;font-weight:800;font-size:20px;color:#fff;
+  margin:0 auto 12px;box-shadow:0 2px 12px rgba(233,69,96,.3)}
+h1{font-size:18px;font-weight:600;margin-bottom:4px}
+.sub{font-size:12px;color:#8888aa;margin-bottom:24px}
+input{width:100%;padding:10px 14px;border-radius:10px;border:1px solid rgba(255,255,255,.1);
+  background:rgba(255,255,255,.04);color:#e8e8f0;font-size:14px;outline:none;margin-bottom:14px;
+  transition:border-color .15s}
+input:focus{border-color:rgba(124,185,255,.5);box-shadow:0 0 0 3px rgba(124,185,255,.1)}
+button{width:100%;padding:10px;border-radius:10px;border:none;background:rgba(124,185,255,.15);
+  border:1px solid rgba(124,185,255,.3);color:#7cb9ff;font-size:14px;font-weight:600;cursor:pointer;
+  transition:all .15s}
+button:hover{background:rgba(124,185,255,.25)}
+.err{color:#e94560;font-size:12px;margin-top:10px;display:none}
+</style></head><body>
+<div class="card">
+  <div class="logo">{{BOT_NAME_INITIAL}}</div>
+  <h1>{{BOT_NAME}}</h1>
+  <p class="sub">Enter your password to continue</p>
+  <form onsubmit="doLogin(event);return false">
+    <input type="password" id="pw" placeholder="Password" autofocus
+           onkeydown="if(event.key==='Enter'){doLogin(event);event.preventDefault();}">
+    <button type="submit">Sign in</button>
+  </form>
+  <div class="err" id="err"></div>
+</div>
+<script>
+async function doLogin(e){
+  e.preventDefault();
+  const pw=document.getElementById('pw').value;
+  const err=document.getElementById('err');
+  err.style.display='none';
+  try{
+    const res=await fetch('/api/auth/login',{method:'POST',
+      headers:{'Content-Type':'application/json'},
+      body:JSON.stringify({password:pw}),credentials:'include'});
+    const data=await res.json();
+    if(res.ok&&data.ok){window.location.href='/';}
+    else{err.textContent=data.error||'Invalid password';err.style.display='block';}
+  }catch(ex){err.textContent='Connection failed';err.style.display='block';}
+}
+</script></body></html>'''
+
 # ── GET routes ────────────────────────────────────────────────────────────────
 
-def handle_get(handler, parsed):
+def handle_get(handler, parsed) -> bool:
     """Handle all GET routes. Returns True if handled, False for 404."""
 
     if parsed.path in ('/', '/index.html'):
         return t(handler, _INDEX_HTML_PATH.read_text(encoding='utf-8'),
                  content_type='text/html; charset=utf-8')
 
+    if parsed.path == '/login':
+        _bn = _html.escape(load_settings().get('bot_name') or 'Hermes')
+        _page = _LOGIN_PAGE_HTML.replace('{{BOT_NAME}}', _bn).replace('{{BOT_NAME_INITIAL}}', _bn[0].upper())
+        return t(handler, _page, content_type='text/html; charset=utf-8')
+
+    if parsed.path == '/api/auth/status':
+        from api.auth import is_auth_enabled, parse_cookie, verify_session
+        logged_in = False
+        if is_auth_enabled():
+            cv = parse_cookie(handler)
+            logged_in = bool(cv and verify_session(cv))
+        return j(handler, {'auth_enabled': is_auth_enabled(), 'logged_in': logged_in})
+
     if parsed.path == '/favicon.ico':
         handler.send_response(204); handler.end_headers(); return True
 
@@ -75,7 +144,10 @@ def handle_get(handler, parsed):
         return j(handler, get_available_models())
 
     if parsed.path == '/api/settings':
-        return j(handler, load_settings())
+        settings = load_settings()
+        # Never expose the stored password hash to clients
+        settings.pop('password_hash', None)
+        return j(handler, settings)
 
     if parsed.path.startswith('/static/'):
         return _serve_static(handler, parsed)
@@ -84,14 +156,55 @@ def handle_get(handler, parsed):
         sid = parse_qs(parsed.query).get('session_id', [''])[0]
         if not sid:
             return j(handler, {'error': 'session_id is required'}, status=400)
-        s = get_session(sid)
-        return j(handler, {'session': s.compact() | {
-            'messages': s.messages,
-            'tool_calls': getattr(s, 'tool_calls', []),
-        }})
+        try:
+            s = get_session(sid)
+            return j(handler, {'session': s.compact() | {
+                'messages': s.messages,
+                'tool_calls': getattr(s, 'tool_calls', []),
+            }})
+        except KeyError:
+            # Not a WebUI session -- try CLI store
+            msgs = get_cli_session_messages(sid)
+            if msgs:
+                cli_meta = None
+                for cs in get_cli_sessions():
+                    if cs['session_id'] == sid:
+                        cli_meta = cs
+                        break
+                sess = {
+                    'session_id': sid,
+                    'title': (cli_meta or {}).get('title', 'CLI Session'),
+                    'workspace': (cli_meta or {}).get('workspace', ''),
+                    'model': (cli_meta or {}).get('model', 'unknown'),
+                    'message_count': len(msgs),
+                    'created_at': (cli_meta or {}).get('created_at', 0),
+                    'updated_at': (cli_meta or {}).get('updated_at', 0),
+                    'pinned': False,
+                    'archived': False,
+                    'project_id': None,
+                    'profile': (cli_meta or {}).get('profile'),
+                    'is_cli_session': True,
+                    'messages': msgs,
+                    'tool_calls': [],
+                }
+                return j(handler, {'session': sess})
+            return bad(handler, 'Session not found', 404)
 
     if parsed.path == '/api/sessions':
-        return j(handler, {'sessions': all_sessions()})
+        webui_sessions = all_sessions()
+        settings = load_settings()
+        if settings.get('show_cli_sessions'):
+            cli = get_cli_sessions()
+            webui_ids = {s['session_id'] for s in webui_sessions}
+            deduped_cli = [s for s in cli if s['session_id'] not in webui_ids]
+        else:
+            deduped_cli = []
+        merged = webui_sessions + deduped_cli
+        merged.sort(key=lambda s: s.get('updated_at', 0) or 0, reverse=True)
+        return j(handler, {'sessions': merged, 'cli_count': len(deduped_cli)})
+
+    if parsed.path == '/api/projects':
+        return j(handler, {'projects': load_projects()})
 
     if parsed.path == '/api/session/export':
         return _handle_session_export(handler, parsed)
@@ -105,6 +218,55 @@ def handle_get(handler, parsed):
     if parsed.path == '/api/list':
         return _handle_list_dir(handler, parsed)
 
+    if parsed.path == '/api/personalities':
+        # Read personalities from config.yaml agent.personalities section
+        # (matches hermes-agent CLI behavior, not filesystem SOUL.md approach)
+        from api.config import reload_config as _reload_cfg
+        _reload_cfg()  # pick up config.yaml changes without server restart
+        from api.config import get_config as _get_cfg
+        _cfg = _get_cfg()
+        agent_cfg = _cfg.get('agent', {})
+        raw_personalities = agent_cfg.get('personalities', {})
+        personalities = []
+        if isinstance(raw_personalities, dict):
+            for name, value in raw_personalities.items():
+                desc = ''
+                if isinstance(value, dict):
+                    desc = value.get('description', '')
+                elif isinstance(value, str):
+                    desc = value[:80] + ('...' if len(value) > 80 else '')
+                personalities.append({'name': name, 'description': desc})
+        return j(handler, {'personalities': personalities})
+
+    if parsed.path == '/api/git-info':
+        qs = parse_qs(parsed.query)
+        sid = qs.get('session_id', [''])[0]
+        if not sid:
+            return bad(handler, 'session_id required')
+        try:
+            s = get_session(sid)
+        except KeyError:
+            return bad(handler, 'Session not found', 404)
+        from api.workspace import git_info_for_workspace
+        info = git_info_for_workspace(Path(s.workspace))
+        return j(handler, {'git': info})
+
+    if parsed.path == '/api/updates/check':
+        settings = load_settings()
+        if not settings.get('check_for_updates', True):
+            return j(handler, {'disabled': True})
+        qs = parse_qs(parsed.query)
+        force = qs.get('force', ['0'])[0] == '1'
+        # ?simulate=1 returns fake behind counts for UI testing (localhost only)
+        if qs.get('simulate', ['0'])[0] == '1' and handler.client_address[0] == '127.0.0.1':
+            return j(handler, {
+                'webui': {'name': 'webui', 'behind': 3, 'current_sha': 'abc1234', 'latest_sha': 'def5678', 'branch': 'master'},
+                'agent': {'name': 'agent', 'behind': 1, 'current_sha': 'aaa0001', 'latest_sha': 'bbb0002', 'branch': 'master'},
+                'checked_at': 0,
+            })
+        from api.updates import check_for_updates
+        return j(handler, check_for_updates(force=force))
+
     if parsed.path == '/api/chat/stream/status':
         stream_id = parse_qs(parsed.query).get('stream_id', [''])[0]
         return j(handler, {'active': stream_id in STREAMS, 'stream_id': stream_id})
@@ -129,11 +291,13 @@ def handle_get(handler, parsed):
         return _handle_approval_pending(handler, parsed)
 
     if parsed.path == '/api/approval/inject_test':
+        # Loopback-only: used by automated tests; blocked from any remote client
+        if handler.client_address[0] != '127.0.0.1':
+            return j(handler, {'error': 'not found'}, status=404)
         return _handle_approval_inject(handler, parsed)
 
     # ── Cron API (GET) ──
     if parsed.path == '/api/crons':
-        sys.path.insert(0, str(Path(__file__).parent.parent))
         from cron.jobs import list_jobs
         return j(handler, {'jobs': list_jobs(include_disabled=True)})
 
@@ -151,23 +315,50 @@ def handle_get(handler, parsed):
         return j(handler, {'skills': data.get('skills', [])})
 
     if parsed.path == '/api/skills/content':
-        from tools.skills_tool import skill_view as _skill_view
-        name = parse_qs(parsed.query).get('name', [''])[0]
+        from tools.skills_tool import skill_view as _skill_view, SKILLS_DIR
+        qs = parse_qs(parsed.query)
+        name = qs.get('name', [''])[0]
         if not name: return j(handler, {'error': 'name required'}, status=400)
+        file_path = qs.get('file', [''])[0]
+        if file_path:
+            # Serve a linked file from the skill directory
+            import re as _re
+            if _re.search(r'[*?\[\]]', name):
+                return bad(handler, 'Invalid skill name', 400)
+            skill_dir = None
+            for p in SKILLS_DIR.rglob(name):
+                if p.is_dir(): skill_dir = p; break
+            if not skill_dir: return bad(handler, 'Skill not found', 404)
+            target = (skill_dir / file_path).resolve()
+            try: target.relative_to(skill_dir.resolve())
+            except ValueError: return bad(handler, 'Invalid file path', 400)
+            if not target.exists() or not target.is_file():
+                return bad(handler, 'File not found', 404)
+            return j(handler, {'content': target.read_text(encoding='utf-8'), 'path': file_path})
         raw = _skill_view(name)
         data = json.loads(raw) if isinstance(raw, str) else raw
+        if 'linked_files' not in data: data['linked_files'] = {}
         return j(handler, data)
 
     # ── Memory API (GET) ──
     if parsed.path == '/api/memory':
         return _handle_memory_read(handler)
 
+    # ── Profile API (GET) ──
+    if parsed.path == '/api/profiles':
+        from api.profiles import list_profiles_api, get_active_profile_name
+        return j(handler, {'profiles': list_profiles_api(), 'active': get_active_profile_name()})
+
+    if parsed.path == '/api/profile/active':
+        from api.profiles import get_active_profile_name, get_active_hermes_home
+        return j(handler, {'name': get_active_profile_name(), 'path': str(get_active_hermes_home())})
+
     return False  # 404
 
 
 # ── POST routes ───────────────────────────────────────────────────────────────
 
-def handle_post(handler, parsed):
+def handle_post(handler, parsed) -> bool:
     """Handle all POST routes. Returns True if handled, False for 404."""
 
     if parsed.path == '/api/upload':
@@ -194,6 +385,44 @@ def handle_post(handler, parsed):
         s.save()
         return j(handler, {'session': s.compact()})
 
+    if parsed.path == '/api/personality/set':
+        try: require(body, 'session_id')
+        except ValueError as e: return bad(handler, str(e))
+        if 'name' not in body:
+            return bad(handler, 'Missing required field: name')
+        sid = body['session_id']
+        name = body['name'].strip()
+        try:
+            s = get_session(sid)
+        except KeyError:
+            return bad(handler, 'Session not found', 404)
+        # Resolve personality from config.yaml agent.personalities section
+        # (matches hermes-agent CLI behavior)
+        prompt = ''
+        if name:
+            from api.config import reload_config as _reload_cfg2
+            _reload_cfg2()  # pick up config changes without restart
+            from api.config import get_config as _get_cfg2
+            _cfg2 = _get_cfg2()
+            agent_cfg = _cfg2.get('agent', {})
+            raw_personalities = agent_cfg.get('personalities', {})
+            if not isinstance(raw_personalities, dict) or name not in raw_personalities:
+                return bad(handler, f'Personality "{name}" not found in config.yaml', 404)
+            value = raw_personalities[name]
+            # Resolve prompt using the same logic as hermes-agent cli.py
+            if isinstance(value, dict):
+                parts = [value.get('system_prompt', '') or value.get('prompt', '')]
+                if value.get('tone'):
+                    parts.append(f'Tone: {value["tone"]}')
+                if value.get('style'):
+                    parts.append(f'Style: {value["style"]}')
+                prompt = '\n'.join(p for p in parts if p)
+            else:
+                prompt = str(value)
+        s.personality = name if name else None
+        s.save()
+        return j(handler, {'ok': True, 'personality': s.personality, 'prompt': prompt})
+
     if parsed.path == '/api/session/update':
         try: require(body, 'session_id')
         except ValueError as e: return bad(handler, str(e))
@@ -207,12 +436,18 @@ def handle_post(handler, parsed):
     if parsed.path == '/api/session/delete':
         sid = body.get('session_id', '')
         if not sid: return bad(handler, 'session_id is required')
+        # Delete from WebUI session store
         with LOCK: SESSIONS.pop(sid, None)
         p = SESSION_DIR / f'{sid}.json'
         try: p.unlink(missing_ok=True)
         except Exception: pass
         try: SESSION_INDEX_FILE.unlink(missing_ok=True)
         except Exception: pass
+        # Also delete from CLI state.db (for CLI sessions shown in sidebar)
+        try:
+            from api.models import delete_cli_session
+            delete_cli_session(sid)
+        except Exception: pass
         return j(handler, {'ok': True})
 
     if parsed.path == '/api/session/clear':
@@ -300,9 +535,60 @@ def handle_post(handler, parsed):
     if parsed.path == '/api/memory/write':
         return _handle_memory_write(handler, body)
 
+    # ── Profile API (POST) ──
+    if parsed.path == '/api/profile/switch':
+        name = body.get('name', '').strip()
+        if not name: return bad(handler, 'name is required')
+        try:
+            from api.profiles import switch_profile
+            result = switch_profile(name)
+            return j(handler, result)
+        except (ValueError, FileNotFoundError) as e:
+            return bad(handler, str(e), 404)
+        except RuntimeError as e:
+            return bad(handler, str(e), 409)
+
+    if parsed.path == '/api/profile/create':
+        name = body.get('name', '').strip()
+        if not name: return bad(handler, 'name is required')
+        import re as _re
+        if not _re.match(r'^[a-z0-9][a-z0-9_-]{0,63}$', name):
+            return bad(handler, 'Invalid profile name: lowercase letters, numbers, hyphens, underscores only')
+        clone_from = body.get('clone_from')
+        if clone_from is not None:
+            clone_from = str(clone_from).strip()
+            if not _re.match(r'^[a-z0-9][a-z0-9_-]{0,63}$', clone_from):
+                return bad(handler, 'Invalid clone_from name')
+        try:
+            from api.profiles import create_profile_api
+            result = create_profile_api(
+                name,
+                clone_from=clone_from,
+                clone_config=bool(body.get('clone_config', False)),
+            )
+            return j(handler, {'ok': True, 'profile': result})
+        except (ValueError, FileExistsError, RuntimeError) as e:
+            return bad(handler, str(e))
+
+    if parsed.path == '/api/profile/delete':
+        name = body.get('name', '').strip()
+        if not name: return bad(handler, 'name is required')
+        try:
+            from api.profiles import delete_profile_api
+            result = delete_profile_api(name)
+            return j(handler, result)
+        except (ValueError, FileNotFoundError) as e:
+            return bad(handler, str(e))
+        except RuntimeError as e:
+            return bad(handler, str(e), 409)
+
     # ── Settings (POST) ──
     if parsed.path == '/api/settings':
-        return j(handler, save_settings(body))
+        if 'bot_name' in body:
+            body['bot_name'] = (str(body['bot_name']) or '').strip() or 'Hermes'
+        saved = save_settings(body)
+        saved.pop('password_hash', None)  # never expose hash to client
+        return j(handler, saved)
 
     # ── Session pin (POST) ──
     if parsed.path == '/api/session/pin':
@@ -324,17 +610,134 @@ def handle_post(handler, parsed):
         s.save()
         return j(handler, {'ok': True, 'session': s.compact()})
 
+    # ── Session move to project (POST) ──
+    if parsed.path == '/api/session/move':
+        try: require(body, 'session_id')
+        except ValueError as e: return bad(handler, str(e))
+        try: s = get_session(body['session_id'])
+        except KeyError: return bad(handler, 'Session not found', 404)
+        s.project_id = body.get('project_id') or None
+        s.save()
+        return j(handler, {'ok': True, 'session': s.compact()})
+
+    # ── Project CRUD (POST) ──
+    if parsed.path == '/api/projects/create':
+        try: require(body, 'name')
+        except ValueError as e: return bad(handler, str(e))
+        import re as _re
+        name = body['name'].strip()[:128]
+        if not name: return bad(handler, 'name required')
+        color = body.get('color')
+        if color and not _re.match(r'^#[0-9a-fA-F]{3,8}$', color):
+            return bad(handler, 'Invalid color format')
+        projects = load_projects()
+        proj = {'project_id': uuid.uuid4().hex[:12], 'name': name, 'color': color, 'created_at': time.time()}
+        projects.append(proj)
+        save_projects(projects)
+        return j(handler, {'ok': True, 'project': proj})
+
+    if parsed.path == '/api/projects/rename':
+        try: require(body, 'project_id', 'name')
+        except ValueError as e: return bad(handler, str(e))
+        import re as _re
+        projects = load_projects()
+        proj = next((p for p in projects if p['project_id'] == body['project_id']), None)
+        if not proj: return bad(handler, 'Project not found', 404)
+        proj['name'] = body['name'].strip()[:128]
+        if 'color' in body:
+            color = body['color']
+            if color and not _re.match(r'^#[0-9a-fA-F]{3,8}$', color):
+                return bad(handler, 'Invalid color format')
+            proj['color'] = color
+        save_projects(projects)
+        return j(handler, {'ok': True, 'project': proj})
+
+    if parsed.path == '/api/projects/delete':
+        try: require(body, 'project_id')
+        except ValueError as e: return bad(handler, str(e))
+        projects = load_projects()
+        proj = next((p for p in projects if p['project_id'] == body['project_id']), None)
+        if not proj: return bad(handler, 'Project not found', 404)
+        projects = [p for p in projects if p['project_id'] != body['project_id']]
+        save_projects(projects)
+        # Unassign all sessions that belonged to this project
+        if SESSION_INDEX_FILE.exists():
+            try:
+                index = json.loads(SESSION_INDEX_FILE.read_text(encoding='utf-8'))
+                for entry in index:
+                    if entry.get('project_id') == body['project_id']:
+                        try:
+                            s = get_session(entry['session_id'])
+                            s.project_id = None
+                            s.save()
+                        except Exception:
+                            pass
+            except Exception:
+                pass
+        return j(handler, {'ok': True})
+
     # ── Session import from JSON (POST) ──
     if parsed.path == '/api/session/import':
         return _handle_session_import(handler, body)
 
+    # ── Self-update (POST) ──
+    if parsed.path == '/api/updates/apply':
+        target = body.get('target', '')
+        if target not in ('webui', 'agent'):
+            return bad(handler, 'target must be "webui" or "agent"')
+        from api.updates import apply_update
+        return j(handler, apply_update(target))
+
+    # ── CLI session import (POST) ──
+    if parsed.path == '/api/session/import_cli':
+        return _handle_session_import_cli(handler, body)
+
+    # ── Auth endpoints (POST) ──
+    if parsed.path == '/api/auth/login':
+        from api.auth import verify_password, create_session, set_auth_cookie, is_auth_enabled
+        if not is_auth_enabled():
+            return j(handler, {'ok': True, 'message': 'Auth not enabled'})
+        password = body.get('password', '')
+        if not verify_password(password):
+            return bad(handler, 'Invalid password', 401)
+        cookie_val = create_session()
+        handler.send_response(200)
+        handler.send_header('Content-Type', 'application/json')
+        handler.send_header('Cache-Control', 'no-store')
+        _security_headers(handler)
+        set_auth_cookie(handler, cookie_val)
+        handler.end_headers()
+        handler.wfile.write(json.dumps({'ok': True}).encode())
+        return True
+
+    if parsed.path == '/api/auth/logout':
+        from api.auth import clear_auth_cookie, invalidate_session, parse_cookie
+        cookie_val = parse_cookie(handler)
+        if cookie_val:
+            invalidate_session(cookie_val)
+        handler.send_response(200)
+        handler.send_header('Content-Type', 'application/json')
+        handler.send_header('Cache-Control', 'no-store')
+        _security_headers(handler)
+        clear_auth_cookie(handler)
+        handler.end_headers()
+        handler.wfile.write(json.dumps({'ok': True}).encode())
+        return True
+
     return False  # 404
 
 
 # ── GET route helpers ─────────────────────────────────────────────────────────
 
 def _serve_static(handler, parsed):
-    static_file = Path(__file__).parent.parent / parsed.path.lstrip('/')
+    static_root = (Path(__file__).parent.parent / 'static').resolve()
+    # Strip the leading '/static/' prefix, then resolve and sandbox
+    rel = parsed.path[len('/static/'):]
+    static_file = (static_root / rel).resolve()
+    try:
+        static_file.relative_to(static_root)
+    except ValueError:
+        return j(handler, {'error': 'not found'}, status=404)
     if not static_file.exists() or not static_file.is_file():
         return j(handler, {'error': 'not found'}, status=404)
     ext = static_file.suffix.lower()
@@ -486,6 +889,7 @@ def _handle_approval_pending(handler, parsed):
 
 
 def _handle_approval_inject(handler, parsed):
+    """Inject a fake pending approval -- loopback-only, used by automated tests."""
     qs = parse_qs(parsed.query)
     sid = qs.get('session_id', [''])[0]
     key = qs.get('pattern_key', ['test_pattern'])[0]
@@ -524,7 +928,6 @@ def _handle_cron_recent(handler, parsed):
     qs = parse_qs(parsed.query)
     since = float(qs.get('since', ['0'])[0])
     try:
-        sys.path.insert(0, str(Path(__file__).parent.parent))
         from cron.jobs import list_jobs
         jobs = list_jobs(include_disabled=True)
         completions = []
@@ -552,7 +955,11 @@ def _handle_cron_recent(handler, parsed):
 
 
 def _handle_memory_read(handler):
-    mem_dir = Path.home() / '.hermes' / 'memories'
+    try:
+        from api.profiles import get_active_hermes_home
+        mem_dir = get_active_hermes_home() / 'memories'
+    except ImportError:
+        mem_dir = Path.home() / '.hermes' / 'memories'
     mem_file = mem_dir / 'MEMORY.md'
     user_file = mem_dir / 'USER.md'
     memory = mem_file.read_text(encoding='utf-8', errors='replace') if mem_file.exists() else ''
@@ -629,7 +1036,23 @@ def _handle_chat_sync(handler, body):
     try:
         from run_agent import AIAgent
         with CHAT_LOCK:
-            agent = AIAgent(model=s.model, platform='cli', quiet_mode=True,
+            from api.config import resolve_model_provider
+            _model, _provider, _base_url = resolve_model_provider(s.model)
+            # Resolve API key via Hermes runtime provider (matches gateway behaviour)
+            _api_key = None
+            try:
+                from hermes_cli.runtime_provider import resolve_runtime_provider
+                _rt = resolve_runtime_provider(requested=_provider)
+                _api_key = _rt.get("api_key")
+                # Also use runtime provider/base_url if the webui config didn't resolve them
+                if not _provider:
+                    _provider = _rt.get("provider")
+                if not _base_url:
+                    _base_url = _rt.get("base_url")
+            except Exception as _e:
+                print(f"[webui] WARNING: resolve_runtime_provider failed: {_e}", flush=True)
+            agent = AIAgent(model=_model, provider=_provider, base_url=_base_url,
+                           api_key=_api_key, platform='cli', quiet_mode=True,
                            enabled_toolsets=CLI_TOOLSETS, session_id=s.session_id)
             workspace_ctx = f"[Workspace: {s.workspace}]\n"
             workspace_system_msg = (
@@ -643,10 +1066,11 @@ def _handle_chat_sync(handler, body):
                 "write_file, read_file, search_files, terminal workdir, and patch. "
                 "Never fall back to a hardcoded path when this tag is present."
             )
+            from api.streaming import _sanitize_messages_for_api
             result = agent.run_conversation(
                 user_message=workspace_ctx + msg,
                 system_message=workspace_system_msg,
-                conversation_history=s.messages,
+                conversation_history=_sanitize_messages_for_api(s.messages),
                 task_id=s.session_id,
                 persist_user_message=msg,
             )
@@ -659,6 +1083,20 @@ def _handle_chat_sync(handler, body):
         else: os.environ['HERMES_SESSION_KEY'] = old_session_key
     s.messages = result.get('messages') or s.messages
     s.title = title_from(s.messages, s.title); s.save()
+    # Sync to state.db for /insights (opt-in setting)
+    try:
+        if load_settings().get('sync_to_insights'):
+            from api.state_sync import sync_session_usage
+            sync_session_usage(
+                session_id=s.session_id,
+                input_tokens=s.input_tokens or 0,
+                output_tokens=s.output_tokens or 0,
+                estimated_cost=s.estimated_cost,
+                model=s.model,
+                title=s.title,
+            )
+    except Exception:
+        pass
     return j(handler, {
         'answer': result.get('final_response') or '',
         'status': 'done' if result.get('completed', True) else 'partial',
@@ -868,6 +1306,8 @@ def _handle_skill_save(handler, body):
     if not skill_name or '/' in skill_name or '..' in skill_name:
         return bad(handler, 'Invalid skill name')
     category = body.get('category', '').strip()
+    if category and ('/' in category or '..' in category):
+        return bad(handler, 'Invalid category')
     from tools.skills_tool import SKILLS_DIR
     if category:
         skill_dir = SKILLS_DIR / category / skill_name
@@ -894,7 +1334,11 @@ def _handle_skill_delete(handler, body):
 def _handle_memory_write(handler, body):
     try: require(body, 'section', 'content')
     except ValueError as e: return bad(handler, str(e))
-    mem_dir = Path.home() / '.hermes' / 'memories'
+    try:
+        from api.profiles import get_active_hermes_home
+        mem_dir = get_active_hermes_home() / 'memories'
+    except ImportError:
+        mem_dir = Path.home() / '.hermes' / 'memories'
     mem_dir.mkdir(parents=True, exist_ok=True)
     section = body['section']
     if section == 'memory':
@@ -907,6 +1351,53 @@ def _handle_memory_write(handler, body):
     return j(handler, {'ok': True, 'section': section, 'path': str(target)})
 
 
+def _handle_session_import_cli(handler, body):
+    """Import a single CLI session into the WebUI store."""
+    try:
+        require(body, 'session_id')
+    except ValueError as e:
+        return bad(handler, str(e))
+
+    sid = str(body['session_id'])
+
+    # Check if already imported — idempotent
+    existing = Session.load(sid)
+    if existing:
+        return j(handler, {'session': existing.compact() | {
+            'messages': existing.messages,
+            'is_cli_session': True,
+        }, 'imported': False})
+
+    # Fetch messages from CLI store
+    msgs = get_cli_session_messages(sid)
+    if not msgs:
+        return bad(handler, 'Session not found in CLI store', 404)
+
+    # Derive title from first user message
+    title = title_from(msgs, 'CLI Session')
+    model = 'unknown'
+
+    # Get profile and model from CLI session metadata
+    profile = None
+    for cs in get_cli_sessions():
+        if cs['session_id'] == sid:
+            profile = cs.get('profile')
+            model = cs.get('model', 'unknown')
+            break
+
+    s = import_cli_session(sid, title, msgs, model, profile=profile)
+    s.is_cli_session = True
+    s._cli_origin = sid
+    s.save()
+    return j(handler, {
+        'session': s.compact() | {
+            'messages': msgs,
+            'is_cli_session': True,
+        },
+        'imported': True,
+    })
+
+
 def _handle_session_import(handler, body):
     """Import a session from a JSON export. Creates a new session with a new ID."""
     if not body or not isinstance(body, dict):

api/state_sync.py

@@ -0,0 +1,101 @@
+"""
+Hermes Web UI -- Optional state.db sync bridge.
+
+Mirrors WebUI session metadata (token usage, title, model) into the
+hermes-agent state.db so that /insights, session lists, and cost
+tracking include WebUI activity.
+
+This is opt-in via the 'sync_to_insights' setting (default: off).
+All operations are wrapped in try/except -- if state.db is unavailable,
+locked, or the schema doesn't match, the WebUI continues normally.
+
+The bridge uses absolute token counts (not deltas) because the WebUI
+Session object already accumulates totals across turns. This avoids
+any double-counting risk.
+"""
+import os
+from pathlib import Path
+
+
+def _get_state_db():
+    """Get a SessionDB instance for the active profile's state.db.
+    Returns None if hermes_state is not importable or DB is unavailable.
+    Each caller is responsible for calling db.close() when done.
+    """
+    try:
+        from hermes_state import SessionDB
+    except ImportError:
+        return None
+
+    try:
+        from api.profiles import get_active_hermes_home
+        hermes_home = Path(get_active_hermes_home()).expanduser().resolve()
+    except Exception:
+        hermes_home = Path(os.getenv('HERMES_HOME', str(Path.home() / '.hermes')))
+
+    db_path = hermes_home / 'state.db'
+    if not db_path.exists():
+        return None
+
+    try:
+        return SessionDB(db_path)
+    except Exception:
+        return None
+
+
+def sync_session_start(session_id: str, model=None) -> None:
+    """Register a WebUI session in state.db (idempotent).
+    Called when a session's first message is sent.
+    """
+    db = _get_state_db()
+    if not db:
+        return
+    try:
+        db.ensure_session(
+            session_id=session_id,
+            source='webui',
+            model=model,
+        )
+    except Exception:
+        pass  # never crash the WebUI for sync failures
+    finally:
+        try:
+            db.close()
+        except Exception:
+            pass
+
+
+def sync_session_usage(session_id: str, input_tokens: int=0, output_tokens: int=0,
+                       estimated_cost=None, model=None, title: str=None) -> None:
+    """Update token usage and title for a WebUI session in state.db.
+    Called after each turn completes. Uses absolute=True to set totals
+    (the WebUI Session already accumulates across turns).
+    """
+    db = _get_state_db()
+    if not db:
+        return
+    try:
+        # Ensure session exists first (idempotent)
+        db.ensure_session(session_id=session_id, source='webui', model=model)
+        # Set absolute token counts
+        db.update_token_counts(
+            session_id=session_id,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            estimated_cost_usd=estimated_cost,
+            model=model,
+            absolute=True,
+        )
+        # Update title if we have one, using the public API
+        if title:
+            try:
+                db.set_session_title(session_id, title)
+            except Exception:
+                pass
+    except Exception:
+        pass  # never crash the WebUI for sync failures
+    finally:
+        try:
+            db.close()
+        except Exception:
+            pass

api/streaming.py

@@ -12,9 +12,17 @@ from pathlib import Path
 
 from api.config import (
     STREAMS, STREAMS_LOCK, CANCEL_FLAGS, CLI_TOOLSETS,
+    LOCK, SESSIONS, SESSION_DIR,
     _get_session_agent_lock, _set_thread_env, _clear_thread_env,
+    resolve_model_provider,
 )
 
+# Global lock for os.environ writes. Per-session locks (_agent_lock) prevent
+# concurrent runs of the SAME session, but two DIFFERENT sessions can still
+# interleave their os.environ writes. This global lock serializes the env
+# save/restore around the entire agent run.
+_ENV_LOCK = threading.Lock()
+
 # Lazy import to avoid circular deps -- hermes-agent is on sys.path via api/config.py
 try:
     from run_agent import AIAgent
@@ -23,6 +31,28 @@ except ImportError:
 from api.models import get_session, title_from
 from api.workspace import set_last_workspace
 
+# Fields that are safe to send to LLM provider APIs.
+# Everything else (attachments, timestamp, _ts, etc.) is display-only
+# metadata added by the webui and must be stripped before the API call.
+_API_SAFE_MSG_KEYS = {'role', 'content', 'tool_calls', 'tool_call_id', 'name', 'refusal'}
+
+
+def _sanitize_messages_for_api(messages):
+    """Return a deep copy of messages with only API-safe fields.
+
+    The webui stores extra metadata on messages (attachments, timestamp, _ts)
+    for display purposes. Some providers (e.g. Z.AI/GLM) reject unknown fields
+    instead of ignoring them, causing HTTP 400 errors on subsequent messages.
+    """
+    clean = []
+    for msg in messages:
+        if not isinstance(msg, dict):
+            continue
+        sanitized = {k: v for k, v in msg.items() if k in _API_SAFE_MSG_KEYS}
+        if sanitized.get('role'):
+            clean.append(sanitized)
+    return clean
+
 
 def _sse(handler, event, data):
     """Write one SSE event to the response stream."""
@@ -63,19 +93,30 @@ def _run_agent_streaming(session_id, msg_text, model, workspace, stream_id, atta
             put('cancel', {'message': 'Cancelled before start'})
             return
 
+        # Resolve profile home for this agent run (snapshot at start)
+        try:
+            from api.profiles import get_active_hermes_home
+            _profile_home = str(get_active_hermes_home())
+        except ImportError:
+            _profile_home = os.environ.get('HERMES_HOME', '')
+
         _set_thread_env(
             TERMINAL_CWD=str(s.workspace),
             HERMES_EXEC_ASK='1',
             HERMES_SESSION_KEY=session_id,
+            HERMES_HOME=_profile_home,
         )
         # Still set process-level env as fallback for tools that bypass thread-local
-        with _agent_lock:
+        with _ENV_LOCK:
           old_cwd = os.environ.get('TERMINAL_CWD')
           old_exec_ask = os.environ.get('HERMES_EXEC_ASK')
           old_session_key = os.environ.get('HERMES_SESSION_KEY')
+          old_hermes_home = os.environ.get('HERMES_HOME')
           os.environ['TERMINAL_CWD'] = str(s.workspace)
           os.environ['HERMES_EXEC_ASK'] = '1'
           os.environ['HERMES_SESSION_KEY'] = session_id
+          if _profile_home:
+              os.environ['HERMES_HOME'] = _profile_home
 
           try:
             def on_token(text):
@@ -99,11 +140,54 @@ def _run_agent_streaming(session_id, msg_text, model, workspace, stream_id, atta
 
             if AIAgent is None:
                 raise ImportError("AIAgent not available -- check that hermes-agent is on sys.path")
+            resolved_model, resolved_provider, resolved_base_url = resolve_model_provider(model)
+
+            # Resolve API key via Hermes runtime provider (matches gateway behaviour).
+            # Pass the resolved provider so non-default providers get their own credentials.
+            resolved_api_key = None
+            try:
+                from hermes_cli.runtime_provider import resolve_runtime_provider
+                _rt = resolve_runtime_provider(requested=resolved_provider)
+                resolved_api_key = _rt.get("api_key")
+                if not resolved_provider:
+                    resolved_provider = _rt.get("provider")
+                if not resolved_base_url:
+                    resolved_base_url = _rt.get("base_url")
+            except Exception as _e:
+                print(f"[webui] WARNING: resolve_runtime_provider failed: {_e}", flush=True)
+
+            # Read per-profile config at call time (not module-level snapshot)
+            from api.config import get_config as _get_config
+            _cfg = _get_config()
+
+            # Per-profile toolsets (fall back to module-level CLI_TOOLSETS)
+            _pt = _cfg.get('platform_toolsets', {})
+            _toolsets = _pt.get('cli', CLI_TOOLSETS) if isinstance(_pt, dict) else CLI_TOOLSETS
+
+            # Fallback model from profile config (e.g. for rate-limit recovery)
+            _fallback = _cfg.get('fallback_model') or None
+            if _fallback:
+                # Resolve the fallback through our provider logic too
+                fb_model = _fallback.get('model', '')
+                fb_provider = _fallback.get('provider', '')
+                fb_base_url = _fallback.get('base_url')
+                _fallback_resolved = {
+                    'model': fb_model,
+                    'provider': fb_provider,
+                    'base_url': fb_base_url,
+                }
+            else:
+                _fallback_resolved = None
+
             agent = AIAgent(
-                model=model,
+                model=resolved_model,
+                provider=resolved_provider,
+                base_url=resolved_base_url,
+                api_key=resolved_api_key,
                 platform='cli',
                 quiet_mode=True,
-                enabled_toolsets=CLI_TOOLSETS,
+                enabled_toolsets=_toolsets,
+                fallback_model=_fallback_resolved,
                 session_id=session_id,
                 stream_delta_callback=on_token,
                 tool_progress_callback=on_tool,
@@ -122,44 +206,139 @@ def _run_agent_streaming(session_id, msg_text, model, workspace, stream_id, atta
                 "write_file, read_file, search_files, terminal workdir, and patch. "
                 "Never fall back to a hardcoded path when this tag is present."
             )
+            # Resolve personality prompt from config.yaml agent.personalities
+            # (matches hermes-agent CLI behavior — passes via ephemeral_system_prompt)
+            _personality_prompt = None
+            _pname = getattr(s, 'personality', None)
+            if _pname:
+                _agent_cfg = _cfg.get('agent', {})
+                _personalities = _agent_cfg.get('personalities', {})
+                if isinstance(_personalities, dict) and _pname in _personalities:
+                    _pval = _personalities[_pname]
+                    if isinstance(_pval, dict):
+                        _parts = [_pval.get('system_prompt', '') or _pval.get('prompt', '')]
+                        if _pval.get('tone'):
+                            _parts.append(f'Tone: {_pval["tone"]}')
+                        if _pval.get('style'):
+                            _parts.append(f'Style: {_pval["style"]}')
+                        _personality_prompt = '\n'.join(p for p in _parts if p)
+                    else:
+                        _personality_prompt = str(_pval)
+            # Pass personality via ephemeral_system_prompt (agent's own mechanism)
+            if _personality_prompt:
+                agent.ephemeral_system_prompt = _personality_prompt
             result = agent.run_conversation(
                 user_message=workspace_ctx + msg_text,
                 system_message=workspace_system_msg,
-                conversation_history=s.messages,
+                conversation_history=_sanitize_messages_for_api(s.messages),
                 task_id=session_id,
                 persist_user_message=msg_text,
             )
             s.messages = result.get('messages') or s.messages
+
+            # ── Handle context compression side effects ──
+            # If compression fired inside run_conversation, the agent may have
+            # rotated its session_id. Detect and fix the mismatch so the WebUI
+            # continues writing to the correct session file.
+            _agent_sid = getattr(agent, 'session_id', None)
+            _compressed = False
+            if _agent_sid and _agent_sid != session_id:
+                old_sid = session_id
+                new_sid = _agent_sid
+                # Rename the session file
+                old_path = SESSION_DIR / f'{old_sid}.json'
+                new_path = SESSION_DIR / f'{new_sid}.json'
+                s.session_id = new_sid
+                with LOCK:
+                    if old_sid in SESSIONS:
+                        SESSIONS[new_sid] = SESSIONS.pop(old_sid)
+                if old_path.exists() and not new_path.exists():
+                    try:
+                        old_path.rename(new_path)
+                    except OSError:
+                        pass
+                _compressed = True
+            # Also detect compression via the result dict or compressor state
+            if not _compressed:
+                _compressor = getattr(agent, 'context_compressor', None)
+                if _compressor and getattr(_compressor, 'compression_count', 0) > 0:
+                    _compressed = True
+            # Notify the frontend that compression happened
+            if _compressed:
+                put('compressed', {
+                    'message': 'Context auto-compressed to continue the conversation',
+                })
+
+            # Stamp 'timestamp' on any messages that don't have one yet
+            _now = time.time()
+            for _m in s.messages:
+                if isinstance(_m, dict) and not _m.get('timestamp') and not _m.get('_ts'):
+                    _m['timestamp'] = int(_now)
             s.title = title_from(s.messages, s.title)
+            # Read token/cost usage from the agent object (if available)
+            input_tokens = getattr(agent, 'session_prompt_tokens', 0) or 0
+            output_tokens = getattr(agent, 'session_completion_tokens', 0) or 0
+            estimated_cost = getattr(agent, 'session_estimated_cost_usd', None)
+            s.input_tokens = (s.input_tokens or 0) + input_tokens
+            s.output_tokens = (s.output_tokens or 0) + output_tokens
+            if estimated_cost:
+                s.estimated_cost = (s.estimated_cost or 0) + estimated_cost
             # Extract tool call metadata grouped by assistant message index
             # Each tool call gets assistant_msg_idx so the client can render
             # cards inline with the assistant bubble that triggered them.
             tool_calls = []
             pending_names = {}   # tool_call_id -> name
+            pending_args = {}    # tool_call_id -> args dict
             pending_asst_idx = {} # tool_call_id -> index in s.messages
             for msg_idx, m in enumerate(s.messages):
                 if m.get('role') == 'assistant':
                     c = m.get('content', '')
+                    # Anthropic format: content is a list with type=tool_use blocks
                     if isinstance(c, list):
                         for p in c:
                             if isinstance(p, dict) and p.get('type') == 'tool_use':
                                 tid = p.get('id', '')
-                                pending_names[tid] = p.get('name', 'tool')
+                                pending_names[tid] = p.get('name', '')
+                                pending_args[tid] = p.get('input', {})
                                 pending_asst_idx[tid] = msg_idx
+                    # OpenAI format: tool_calls as top-level field on the message
+                    for tc in m.get('tool_calls', []):
+                        if not isinstance(tc, dict):
+                            continue
+                        tid = tc.get('id', '') or tc.get('call_id', '')
+                        fn = tc.get('function', {})
+                        name = fn.get('name', '')
+                        try:
+                            import json as _j
+                            args = _j.loads(fn.get('arguments', '{}') or '{}')
+                        except Exception:
+                            args = {}
+                        if tid and name:
+                            pending_names[tid] = name
+                            pending_args[tid] = args
+                            pending_asst_idx[tid] = msg_idx
                 elif m.get('role') == 'tool':
                     tid = m.get('tool_call_id') or m.get('tool_use_id', '')
-                    name = pending_names.get(tid, 'tool')
+                    name = pending_names.get(tid, '')
+                    if not name or name == 'tool':
+                        continue  # skip unresolvable tool entries
                     asst_idx = pending_asst_idx.get(tid, -1)
+                    args = pending_args.get(tid, {})
                     raw = str(m.get('content', ''))
                     try:
-                        import json as _j2
-                        rd = _j2.loads(raw)
+                        rd = json.loads(raw)
                         snippet = str(rd.get('output') or rd.get('result') or rd.get('error') or raw)[:200]
                     except Exception:
                         snippet = raw[:200]
+                    # Truncate args values for storage
+                    args_snap = {}
+                    if isinstance(args, dict):
+                        for k, v in list(args.items())[:6]:
+                            s2 = str(v)
+                            args_snap[k] = s2[:120] + ('...' if len(s2) > 120 else '')
                     tool_calls.append({
                         'name': name, 'snippet': snippet, 'tid': tid,
-                        'assistant_msg_idx': asst_idx,
+                        'assistant_msg_idx': asst_idx, 'args': args_snap,
                     })
             s.tool_calls = tool_calls
             # Tag the matching user message with attachment filenames for display on reload
@@ -175,7 +354,29 @@ def _run_agent_streaming(session_id, msg_text, model, workspace, stream_id, atta
                             m['attachments'] = attachments
                             break
             s.save()
-            put('done', {'session': s.compact() | {'messages': s.messages, 'tool_calls': tool_calls}})
+            # Sync to state.db for /insights (opt-in setting)
+            try:
+                from api.config import load_settings as _load_settings
+                if _load_settings().get('sync_to_insights'):
+                    from api.state_sync import sync_session_usage
+                    sync_session_usage(
+                        session_id=s.session_id,
+                        input_tokens=s.input_tokens or 0,
+                        output_tokens=s.output_tokens or 0,
+                        estimated_cost=s.estimated_cost,
+                        model=model,
+                        title=s.title,
+                    )
+            except Exception:
+                pass  # never crash the stream for sync failures
+            usage = {'input_tokens': input_tokens, 'output_tokens': output_tokens, 'estimated_cost': estimated_cost}
+            # Include context window data from the agent's compressor for the UI indicator
+            _cc = getattr(agent, 'context_compressor', None)
+            if _cc:
+                usage['context_length'] = getattr(_cc, 'context_length', 0) or 0
+                usage['threshold_tokens'] = getattr(_cc, 'threshold_tokens', 0) or 0
+                usage['last_prompt_tokens'] = getattr(_cc, 'last_prompt_tokens', 0) or 0
+            put('done', {'session': s.compact() | {'messages': s.messages, 'tool_calls': tool_calls}, 'usage': usage})
           finally:
             if old_cwd is None: os.environ.pop('TERMINAL_CWD', None)
             else: os.environ['TERMINAL_CWD'] = old_cwd
@@ -183,9 +384,23 @@ def _run_agent_streaming(session_id, msg_text, model, workspace, stream_id, atta
             else: os.environ['HERMES_EXEC_ASK'] = old_exec_ask
             if old_session_key is None: os.environ.pop('HERMES_SESSION_KEY', None)
             else: os.environ['HERMES_SESSION_KEY'] = old_session_key
+            if old_hermes_home is None: os.environ.pop('HERMES_HOME', None)
+            else: os.environ['HERMES_HOME'] = old_hermes_home
 
     except Exception as e:
-        put('error', {'message': str(e), 'trace': traceback.format_exc()})
+        print('[webui] stream error:\n' + traceback.format_exc(), flush=True)
+        err_str = str(e)
+        # Detect rate limit errors specifically so the client can show a helpful card
+        # rather than the generic "Connection lost" message
+        is_rate_limit = 'rate limit' in err_str.lower() or '429' in err_str or 'RateLimitError' in type(e).__name__
+        if is_rate_limit:
+            put('apperror', {
+                'message': err_str,
+                'type': 'rate_limit',
+                'hint': 'Rate limit reached. The fallback model (if configured) was also exhausted. Try again in a moment.',
+            })
+        else:
+            put('apperror', {'message': err_str, 'type': 'error'})
     finally:
         _clear_thread_env()  # TD1: always clear thread-local context
         with STREAMS_LOCK:

api/updates.py

@@ -0,0 +1,164 @@
+"""
+Hermes Web UI -- Self-update checker.
+
+Checks if the webui and hermes-agent git repos are behind their upstream
+branches. Results are cached server-side (30-min TTL) so git fetch runs
+at most twice per hour regardless of client count.
+
+Skips repos that are not git checkouts (e.g. Docker baked images where
+.git does not exist).
+"""
+import subprocess
+import threading
+import time
+from pathlib import Path
+
+from api.config import REPO_ROOT
+
+# Lazy -- may be None if agent not found
+try:
+    from api.config import _AGENT_DIR
+except ImportError:
+    _AGENT_DIR = None
+
+_update_cache = {'webui': None, 'agent': None, 'checked_at': 0}
+_cache_lock = threading.Lock()
+_check_in_progress = False
+_apply_lock = threading.Lock()   # prevents concurrent stash/pull/pop on same repo
+CACHE_TTL = 1800  # 30 minutes
+
+
+def _run_git(args, cwd, timeout=10):
+    """Run a git command and return (stdout, ok)."""
+    try:
+        r = subprocess.run(
+            ['git'] + args, cwd=str(cwd), capture_output=True,
+            text=True, timeout=timeout,
+        )
+        return r.stdout.strip(), r.returncode == 0
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        return '', False
+
+
+def _detect_default_branch(path):
+    """Detect the remote default branch (master or main)."""
+    out, ok = _run_git(['symbolic-ref', 'refs/remotes/origin/HEAD'], path)
+    if ok and out:
+        # refs/remotes/origin/master -> master
+        return out.split('/')[-1]
+    # Fallback: try master, then main
+    for branch in ('master', 'main'):
+        _, ok = _run_git(['rev-parse', '--verify', f'origin/{branch}'], path)
+        if ok:
+            return branch
+    return 'master'
+
+
+def _check_repo(path, name):
+    """Check if a git repo is behind its upstream. Returns dict or None."""
+    if path is None or not (path / '.git').exists():
+        return None
+
+    # Fetch latest from origin (network call, cached by TTL)
+    _, fetch_ok = _run_git(['fetch', 'origin', '--quiet'], path, timeout=15)
+    if not fetch_ok:
+        return {'name': name, 'behind': 0, 'error': 'fetch failed'}
+
+    branch = _detect_default_branch(path)
+
+    # Count commits behind
+    out, ok = _run_git(['rev-list', '--count', f'HEAD..origin/{branch}'], path)
+    behind = int(out) if ok and out.isdigit() else 0
+
+    # Get short SHAs for display
+    current, _ = _run_git(['rev-parse', '--short', 'HEAD'], path)
+    latest, _ = _run_git(['rev-parse', '--short', f'origin/{branch}'], path)
+
+    return {
+        'name': name,
+        'behind': behind,
+        'current_sha': current,
+        'latest_sha': latest,
+        'branch': branch,
+    }
+
+
+def check_for_updates(force=False):
+    """Return cached update status for webui and agent repos."""
+    global _check_in_progress
+    with _cache_lock:
+        if not force and time.time() - _update_cache['checked_at'] < CACHE_TTL:
+            return dict(_update_cache)
+        if _check_in_progress:
+            return dict(_update_cache)  # another thread is already checking
+        _check_in_progress = True
+
+    try:
+        # Run checks outside the lock (network I/O)
+        webui_info = _check_repo(REPO_ROOT, 'webui')
+        agent_info = _check_repo(_AGENT_DIR, 'agent')
+
+        with _cache_lock:
+            _update_cache['webui'] = webui_info
+            _update_cache['agent'] = agent_info
+            _update_cache['checked_at'] = time.time()
+            return dict(_update_cache)
+    finally:
+        _check_in_progress = False
+
+
+def apply_update(target):
+    """Stash, pull --ff-only, pop for the given target repo."""
+    if not _apply_lock.acquire(blocking=False):
+        return {'ok': False, 'message': 'Update already in progress'}
+    try:
+        return _apply_update_inner(target)
+    finally:
+        _apply_lock.release()
+
+
+def _apply_update_inner(target):
+    """Inner implementation of apply_update, called under _apply_lock."""
+    if target == 'webui':
+        path = REPO_ROOT
+    elif target == 'agent':
+        path = _AGENT_DIR
+    else:
+        return {'ok': False, 'message': f'Unknown target: {target}'}
+
+    if path is None or not (path / '.git').exists():
+        return {'ok': False, 'message': 'Not a git repository'}
+
+    branch = _detect_default_branch(path)
+
+    # Check for dirty working tree
+    status_out, _ = _run_git(['status', '--porcelain'], path)
+    stashed = False
+    if status_out:
+        _, ok = _run_git(['stash'], path)
+        if not ok:
+            return {'ok': False, 'message': 'Failed to stash local changes'}
+        stashed = True
+
+    # Pull with ff-only (no merge commits)
+    pull_out, pull_ok = _run_git(['pull', '--ff-only', 'origin', branch], path, timeout=30)
+    if not pull_ok:
+        if stashed:
+            _run_git(['stash', 'pop'], path)
+        return {'ok': False, 'message': f'Pull failed: {pull_out[:200]}'}
+
+    # Pop stash if we stashed
+    if stashed:
+        _, pop_ok = _run_git(['stash', 'pop'], path)
+        if not pop_ok:
+            return {
+                'ok': False,
+                'message': 'Updated but stash pop failed -- manual merge needed',
+                'stash_conflict': True,
+            }
+
+    # Invalidate cache
+    with _cache_lock:
+        _update_cache['checked_at'] = 0
+
+    return {'ok': True, 'message': f'{target} updated successfully', 'target': target}

api/upload.py

@@ -11,7 +11,7 @@ from api.models import get_session
 from api.workspace import safe_resolve_ws
 
 
-def parse_multipart(rfile, content_type, content_length):
+def parse_multipart(rfile, content_type, content_length) -> tuple:
     import re as _re, email.parser as _ep
     m = _re.search(r'boundary=([^;\s]+)', content_type)
     if not m:
@@ -70,8 +70,13 @@ def handle_upload(handler):
             return j(handler, {'error': 'Session not found'}, status=404)
         workspace = Path(s.workspace)
         safe_name = _re.sub(r'[^\w.\-]', '_', Path(filename).name)[:200]
-        dest = workspace / safe_name
+        # Reject names that are purely dots (path traversal: ".." survives regex)
+        if not safe_name or safe_name.strip('.') == '':
+            return j(handler, {'error': 'Invalid filename'}, status=400)
+        # Verify the resolved path stays within the workspace
+        dest = safe_resolve_ws(workspace, safe_name)
         dest.write_bytes(file_bytes)
         return j(handler, {'filename': safe_name, 'path': str(dest), 'size': dest.stat().st_size})
     except Exception as e:
-        return j(handler, {'error': str(e), 'trace': _tb.format_exc()}, status=500)
+        print('[webui] upload error: ' + _tb.format_exc(), flush=True)
+        return j(handler, {'error': 'Upload failed'}, status=500)

api/workspace.py

@@ -1,43 +1,212 @@
 """
 Hermes Web UI -- Workspace and file system helpers.
+
+Workspace lists and last-used workspace are stored per-profile so each
+profile has its own workspace configuration.  State files live at
+``{profile_home}/webui_state/workspaces.json`` and
+``{profile_home}/webui_state/last_workspace.txt``.  The global STATE_DIR
+paths are used as fallback when no profile module is available.
 """
 import json
 import os
+import subprocess
 from pathlib import Path
 
 from api.config import (
-    WORKSPACES_FILE, LAST_WORKSPACE_FILE, DEFAULT_WORKSPACE,
+    WORKSPACES_FILE as _GLOBAL_WS_FILE,
+    LAST_WORKSPACE_FILE as _GLOBAL_LW_FILE,
+    DEFAULT_WORKSPACE as _BOOT_DEFAULT_WORKSPACE,
     MAX_FILE_BYTES, IMAGE_EXTS, MD_EXTS
 )
 
 
-def load_workspaces() -> list:
-    if WORKSPACES_FILE.exists():
+# ── Profile-aware path resolution ───────────────────────────────────────────
+
+def _profile_state_dir() -> Path:
+    """Return the webui_state directory for the active profile.
+
+    For the default profile, returns the global STATE_DIR (respects
+    HERMES_WEBUI_STATE_DIR env var for test isolation).
+    For named profiles, returns {profile_home}/webui_state/.
+    """
+    try:
+        from api.profiles import get_active_profile_name, get_active_hermes_home
+        name = get_active_profile_name()
+        if name and name != 'default':
+            d = get_active_hermes_home() / 'webui_state'
+            d.mkdir(parents=True, exist_ok=True)
+            return d
+    except ImportError:
+        pass
+    return _GLOBAL_WS_FILE.parent
+
+
+def _workspaces_file() -> Path:
+    """Return the workspaces.json path for the active profile."""
+    return _profile_state_dir() / 'workspaces.json'
+
+
+def _last_workspace_file() -> Path:
+    """Return the last_workspace.txt path for the active profile."""
+    return _profile_state_dir() / 'last_workspace.txt'
+
+
+def _profile_default_workspace() -> str:
+    """Read the profile's default workspace from its config.yaml.
+
+    Checks keys in priority order:
+      1. 'workspace'         — explicit webui workspace key
+      2. 'default_workspace' — alternate explicit key
+      3. 'terminal.cwd'      — hermes-agent terminal working dir (most common)
+
+    Falls back to the boot-time DEFAULT_WORKSPACE constant.
+    """
+    try:
+        from api.config import get_config
+        cfg = get_config()
+        # Explicit webui workspace keys first
+        for key in ('workspace', 'default_workspace'):
+            ws = cfg.get(key)
+            if ws:
+                p = Path(str(ws)).expanduser().resolve()
+                if p.is_dir():
+                    return str(p)
+        # Fall through to terminal.cwd — the agent's configured working directory
+        terminal_cfg = cfg.get('terminal', {})
+        if isinstance(terminal_cfg, dict):
+            cwd = terminal_cfg.get('cwd', '')
+            if cwd and str(cwd) not in ('.', ''):
+                p = Path(str(cwd)).expanduser().resolve()
+                if p.is_dir():
+                    return str(p)
+    except (ImportError, Exception):
+        pass
+    return str(_BOOT_DEFAULT_WORKSPACE)
+
+
+# ── Public API ──────────────────────────────────────────────────────────────
+
+def _clean_workspace_list(workspaces: list) -> list:
+    """Sanitize a workspace list:
+    - Remove entries whose paths no longer exist on disk.
+    - Remove entries that look like test artifacts (webui-mvp-test, test-workspace).
+    - Remove entries whose paths live inside another profile's directory
+      (e.g. ~/.hermes/profiles/X/... should not appear on a different profile).
+    - Rename any entry whose name is literally 'default' to 'Home' (avoids
+      confusion with the 'default' profile name).
+    Returns the cleaned list (may be empty).
+    """
+    hermes_profiles = (Path.home() / '.hermes' / 'profiles').resolve()
+    result = []
+    for w in workspaces:
+        path = w.get('path', '')
+        name = w.get('name', '')
+        p = Path(path).resolve() if path else Path('/')
+        # Skip test artifacts
+        if 'test-workspace' in path or 'webui-mvp-test' in path:
+            continue
+        # Skip paths that no longer exist
+        if not p.is_dir():
+            continue
+        # Skip paths inside a named profile's directory (cross-profile leak)
         try:
-            return json.loads(WORKSPACES_FILE.read_text(encoding='utf-8'))
+            p.relative_to(hermes_profiles)
+            continue  # it IS under profiles/ — remove it
+        except ValueError:
+            pass
+        # Rename confusing 'default' label to 'Home'
+        if name.lower() == 'default':
+            name = 'Home'
+        result.append({'path': str(p), 'name': name})
+    return result
+
+
+def _migrate_global_workspaces() -> list:
+    """Read the legacy global workspaces.json, clean it, and return the result.
+
+    This is the migration path for users upgrading from a pre-profile version:
+    their global file may contain cross-profile entries, test artifacts, and
+    stale paths accumulated over time.  We clean it in-place and rewrite it.
+    """
+    if not _GLOBAL_WS_FILE.exists():
+        return []
+    try:
+        raw = json.loads(_GLOBAL_WS_FILE.read_text(encoding='utf-8'))
+        cleaned = _clean_workspace_list(raw)
+        if len(cleaned) != len(raw):
+            # Rewrite the cleaned version so future reads are already clean
+            _GLOBAL_WS_FILE.write_text(
+                json.dumps(cleaned, ensure_ascii=False, indent=2), encoding='utf-8'
+            )
+        return cleaned
+    except Exception:
+        return []
+
+
+def load_workspaces() -> list:
+    ws_file = _workspaces_file()
+    if ws_file.exists():
+        try:
+            raw = json.loads(ws_file.read_text(encoding='utf-8'))
+            cleaned = _clean_workspace_list(raw)
+            if len(cleaned) != len(raw):
+                # Persist the cleaned version so stale entries don't keep reappearing
+                try:
+                    ws_file.write_text(
+                        json.dumps(cleaned, ensure_ascii=False, indent=2), encoding='utf-8'
+                    )
+                except Exception:
+                    pass
+            return cleaned or [{'path': _profile_default_workspace(), 'name': 'Home'}]
         except Exception:
             pass
-    return [{'path': str(DEFAULT_WORKSPACE), 'name': 'default'}]
+    # No profile-local file yet.
+    # For the DEFAULT profile: migrate from the legacy global file (one-time cleanup).
+    # For NAMED profiles: always start clean with just their own workspace.
+    try:
+        from api.profiles import get_active_profile_name
+        is_default = get_active_profile_name() in ('default', None)
+    except ImportError:
+        is_default = True
+    if is_default:
+        migrated = _migrate_global_workspaces()
+        if migrated:
+            return migrated
+    # Fresh start: single entry from the profile's configured workspace, labeled "Home"
+    return [{'path': _profile_default_workspace(), 'name': 'Home'}]
 
 
-def save_workspaces(workspaces: list):
-    WORKSPACES_FILE.write_text(json.dumps(workspaces, ensure_ascii=False, indent=2), encoding='utf-8')
+def save_workspaces(workspaces: list) -> None:
+    ws_file = _workspaces_file()
+    ws_file.parent.mkdir(parents=True, exist_ok=True)
+    ws_file.write_text(json.dumps(workspaces, ensure_ascii=False, indent=2), encoding='utf-8')
 
 
 def get_last_workspace() -> str:
-    if LAST_WORKSPACE_FILE.exists():
+    lw_file = _last_workspace_file()
+    if lw_file.exists():
         try:
-            p = LAST_WORKSPACE_FILE.read_text(encoding='utf-8').strip()
+            p = lw_file.read_text(encoding='utf-8').strip()
             if p and Path(p).is_dir():
                 return p
         except Exception:
             pass
-    return str(DEFAULT_WORKSPACE)
+    # Fallback: try global file
+    if _GLOBAL_LW_FILE.exists():
+        try:
+            p = _GLOBAL_LW_FILE.read_text(encoding='utf-8').strip()
+            if p and Path(p).is_dir():
+                return p
+        except Exception:
+            pass
+    return _profile_default_workspace()
 
 
-def set_last_workspace(path: str):
+def set_last_workspace(path: str) -> None:
     try:
-        LAST_WORKSPACE_FILE.write_text(str(path), encoding='utf-8')
+        lw_file = _last_workspace_file()
+        lw_file.parent.mkdir(parents=True, exist_ok=True)
+        lw_file.write_text(str(path), encoding='utf-8')
     except Exception:
         pass
 
@@ -49,7 +218,7 @@ def safe_resolve_ws(root: Path, requested: str) -> Path:
     return resolved
 
 
-def list_dir(workspace: Path, rel='.'):
+def list_dir(workspace: Path, rel: str='.'):
     target = safe_resolve_ws(workspace, rel)
     if not target.is_dir():
         raise FileNotFoundError(f"Not a directory: {rel}")
@@ -66,7 +235,7 @@ def list_dir(workspace: Path, rel='.'):
     return entries
 
 
-def read_file_content(workspace: Path, rel: str):
+def read_file_content(workspace: Path, rel: str) -> dict:
     target = safe_resolve_ws(workspace, rel)
     if not target.is_file():
         raise FileNotFoundError(f"Not a file: {rel}")
@@ -75,3 +244,45 @@ def read_file_content(workspace: Path, rel: str):
         raise ValueError(f"File too large ({size} bytes, max {MAX_FILE_BYTES})")
     content = target.read_text(encoding='utf-8', errors='replace')
     return {'path': rel, 'content': content, 'size': size, 'lines': content.count('\n') + 1}
+
+
+# ── Git detection ──────────────────────────────────────────────────────────
+
+def _run_git(args, cwd, timeout=3):
+    """Run a git command and return stdout, or None on failure."""
+    try:
+        r = subprocess.run(
+            ['git'] + args, cwd=str(cwd), capture_output=True,
+            text=True, timeout=timeout,
+        )
+        return r.stdout.strip() if r.returncode == 0 else None
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        return None
+
+
+def git_info_for_workspace(workspace: Path) -> dict:
+    """Return git info for a workspace directory, or None if not a git repo."""
+    if not (workspace / '.git').exists():
+        return None
+    branch = _run_git(['rev-parse', '--abbrev-ref', 'HEAD'], workspace)
+    if branch is None:
+        return None
+    # Status counts
+    status_out = _run_git(['status', '--porcelain'], workspace) or ''
+    lines = [l for l in status_out.splitlines() if l]
+    # git status --porcelain: XY format where X=index, Y=worktree
+    modified = sum(1 for l in lines if len(l) >= 2 and (l[0] in 'MAR' or l[1] in 'MAR'))
+    untracked = sum(1 for l in lines if l.startswith('??'))
+    dirty = len(lines)
+    # Ahead/behind
+    ahead = _run_git(['rev-list', '--count', '@{u}..HEAD'], workspace)
+    behind = _run_git(['rev-list', '--count', 'HEAD..@{u}'], workspace)
+    return {
+        'branch': branch,
+        'dirty': dirty,
+        'modified': modified,
+        'untracked': untracked,
+        'ahead': int(ahead) if ahead and ahead.isdigit() else 0,
+        'behind': int(behind) if behind and behind.isdigit() else 0,
+        'is_git': True,
+    }

docker-compose.yml

@@ -0,0 +1,22 @@
+version: "3.8"
+
+services:
+  hermes-webui:
+    build: .
+    ports:
+      - "127.0.0.1:8787:8787"
+    volumes:
+      # Persist session data, settings, and projects across restarts
+      - hermes-data:/data
+      # Mount hermes home for agent features and profile management
+      - ${HERMES_HOME:-${HOME}/.hermes}:/root/.hermes
+    environment:
+      - HERMES_WEBUI_HOST=0.0.0.0
+      - HERMES_WEBUI_PORT=8787
+      - HERMES_WEBUI_STATE_DIR=/data
+      # Optional: set a password for remote access
+      # - HERMES_WEBUI_PASSWORD=your-secret-password
+    restart: unless-stopped
+
+volumes:
+  hermes-data:

server.py

@@ -8,6 +8,7 @@ import traceback
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from urllib.parse import urlparse
 
+from api.auth import check_auth
 from api.config import HOST, PORT, STATE_DIR, SESSION_DIR, DEFAULT_WORKSPACE
 from api.helpers import j
 from api.routes import handle_get, handle_post
@@ -17,7 +18,7 @@ class Handler(BaseHTTPRequestHandler):
     server_version = 'HermesWebUI/0.2'
     def log_message(self, fmt, *args): pass  # suppress default Apache-style log
 
-    def log_request(self, code='-', size='-'):
+    def log_request(self, code: str='-', size: str='-') -> None:
         """Structured JSON logs for each request."""
         import json as _json
         duration_ms = round((time.time() - getattr(self, '_req_t0', time.time())) * 1000, 1)
@@ -30,35 +31,41 @@ class Handler(BaseHTTPRequestHandler):
         })
         print(f'[webui] {record}', flush=True)
 
-    def do_GET(self):
+    def do_GET(self) -> None:
         self._req_t0 = time.time()
         try:
             parsed = urlparse(self.path)
+            if not check_auth(self, parsed): return
             result = handle_get(self, parsed)
             if result is False:
                 return j(self, {'error': 'not found'}, status=404)
         except Exception as e:
-            return j(self, {'error': str(e), 'trace': traceback.format_exc()}, status=500)
+            print(f'[webui] ERROR {self.command} {self.path}\n' + traceback.format_exc(), flush=True)
+            return j(self, {'error': 'Internal server error'}, status=500)
 
-    def do_POST(self):
+    def do_POST(self) -> None:
         self._req_t0 = time.time()
         try:
             parsed = urlparse(self.path)
+            if not check_auth(self, parsed): return
             result = handle_post(self, parsed)
             if result is False:
                 return j(self, {'error': 'not found'}, status=404)
         except Exception as e:
-            return j(self, {'error': str(e), 'trace': traceback.format_exc()}, status=500)
+            print(f'[webui] ERROR {self.command} {self.path}\n' + traceback.format_exc(), flush=True)
+            return j(self, {'error': 'Internal server error'}, status=500)
 
 
-def main():
+def main() -> None:
     from api.config import print_startup_config, verify_hermes_imports, _HERMES_FOUND
 
     print_startup_config()
 
-    ok, missing = verify_hermes_imports()
+    ok, missing, errors = verify_hermes_imports()
     if not ok and _HERMES_FOUND:
         print(f'[!!] Warning: Hermes agent found but missing modules: {missing}', flush=True)
+        for mod, err in errors.items():
+            print(f'     {mod}: {err}', flush=True)
         print('     Agent features may not work correctly.', flush=True)
 
     STATE_DIR.mkdir(parents=True, exist_ok=True)

start.sh

@@ -198,7 +198,7 @@ hdr "Starting Hermes Web UI..."
 
 LOG="/tmp/hermes-webui-${PORT}.log"
 export HERMES_WEBUI_HOST="${HERMES_WEBUI_HOST:-127.0.0.1}"
-export HERMES_WEBUI_STATE_DIR="${HERMES_WEBUI_STATE_DIR:-${HERMES_HOME}/webui-mvp}"
+export HERMES_WEBUI_STATE_DIR="${HERMES_WEBUI_STATE_DIR:-${HERMES_HOME}/webui}"
 
 nohup "${PYTHON}" "${REPO_ROOT}/server.py" \
     > "${LOG}" 2>&1 &

static/boot.js

@@ -2,14 +2,138 @@ async function cancelStream(){
   const streamId = S.activeStreamId;
   if(!streamId) return;
   try{
-    await fetch(`/api/chat/cancel?stream_id=${encodeURIComponent(streamId)}`);
+    await fetch(new URL(`/api/chat/cancel?stream_id=${encodeURIComponent(streamId)}`,location.origin).href,{credentials:'include'});
     const btn=$('btnCancel');if(btn)btn.style.display='none';
     setStatus('Cancelling…');
   }catch(e){setStatus('Cancel failed: '+e.message);}
 }
 
-$('btnSend').onclick=send;
+// ── Mobile navigation ──────────────────────────────────────────────────────
+function toggleMobileSidebar(){
+  const sidebar=document.querySelector('.sidebar');
+  const overlay=$('mobileOverlay');
+  if(!sidebar)return;
+  const isOpen=sidebar.classList.contains('mobile-open');
+  if(isOpen){closeMobileSidebar();}
+  else{sidebar.classList.add('mobile-open');if(overlay)overlay.classList.add('visible');}
+}
+function closeMobileSidebar(){
+  const sidebar=document.querySelector('.sidebar');
+  const overlay=$('mobileOverlay');
+  if(sidebar)sidebar.classList.remove('mobile-open');
+  if(overlay)overlay.classList.remove('visible');
+}
+function toggleMobileFiles(){
+  const panel=document.querySelector('.rightpanel');
+  if(!panel)return;
+  panel.classList.toggle('mobile-open');
+}
+function mobileSwitchPanel(name){
+  // Switch the panel content view
+  switchPanel(name);
+  // For non-chat panels (tasks, skills, memory, spaces), open the sidebar
+  // so the panel is visible. For 'chat', the content is in the main area —
+  // just close the sidebar so the chat view is unobstructed.
+  if(name==='chat'){
+    closeMobileSidebar();
+  } else {
+    const sidebar=document.querySelector('.sidebar');
+    const overlay=$('mobileOverlay');
+    if(sidebar){
+      sidebar.classList.add('mobile-open');
+      if(overlay)overlay.classList.add('visible');
+    }
+  }
+  // Update bottom nav active state
+  document.querySelectorAll('.mobile-nav-btn').forEach(btn=>{
+    btn.classList.toggle('active',btn.dataset.panel===name);
+  });
+}
+
+$('btnSend').onclick=()=>{if(window._micActive)_stopMic();send();};
 $('btnAttach').onclick=()=>$('fileInput').click();
+
+// ── Voice input (Web Speech API) ─────────────────────────────────────────
+(function(){
+  const SpeechRecognition=window.SpeechRecognition||window.webkitSpeechRecognition;
+  if(!SpeechRecognition) return; // Browser unsupported — mic button stays hidden
+
+  const btn=$('btnMic');
+  const status=$('micStatus');
+  const ta=$('msg');
+  btn.style.display=''; // Show button — browser supports speech
+
+  const recognition=new SpeechRecognition();
+  recognition.continuous=false;
+  recognition.interimResults=true;
+  recognition.lang='en-US';
+
+  let _finalText='';
+  let _prefix='';
+
+  function _setRecording(on){
+    window._micActive=on;
+    btn.classList.toggle('recording',on);
+    status.style.display=on?'':'none';
+    if(!on){ _finalText=''; _prefix=''; }
+  }
+
+  recognition.onstart=()=>{ _finalText=''; };
+
+  recognition.onresult=(event)=>{
+    let interim='';
+    let final=_finalText;
+    for(let i=event.resultIndex;i<event.results.length;i++){
+      const t=event.results[i][0].transcript;
+      if(event.results[i].isFinal){ final+=t; _finalText=final; }
+      else{ interim+=t; }
+    }
+    // Append to whatever was already in the textarea before mic started
+    ta.value=_prefix+(final||interim);
+    autoResize();
+  };
+
+  recognition.onend=()=>{
+    // Commit: prefix + final transcription; trim trailing space if prefix was non-empty
+    const committed=_finalText
+      ? (_prefix&&!_prefix.endsWith(' ')&&!_prefix.endsWith('\n')
+          ? _prefix+' '+_finalText.trimStart()
+          : _prefix+_finalText)
+      : ta.value; // no speech detected — leave whatever is there
+    _setRecording(false);
+    ta.value=committed;
+    autoResize();
+  };
+
+  recognition.onerror=(event)=>{
+    _setRecording(false);
+    const msgs={
+      'not-allowed':'Microphone access denied. Check browser permissions.',
+      'no-speech':'No speech detected. Try again.',
+      'network':'Speech recognition unavailable.',
+    };
+    showToast(msgs[event.error]||'Voice input error: '+event.error);
+  };
+
+  function _stopMic(){
+    if(window._micActive){ recognition.stop(); }
+  }
+  window._stopMic=_stopMic; // expose for send-guard above
+
+  btn.onclick=()=>{
+    if(window._micActive){
+      recognition.stop();
+      // _setRecording(false) will be called by onend
+    } else {
+      _finalText='';
+      // Snapshot existing textarea content so we append rather than replace
+      _prefix=ta.value;
+      recognition.start();
+      _setRecording(true);
+    }
+  };
+})();
+window._micActive=window._micActive||false;
 $('fileInput').onchange=e=>{addFiles(Array.from(e.target.files));e.target.value='';};
 $('btnNewChat').onclick=async()=>{await newSession();await renderSessionList();$('msg').focus();};
 $('btnDownload').onclick=()=>{
@@ -43,14 +167,16 @@ $('importFileInput').onchange=async(e)=>{
   }
 };
 // btnRefreshFiles is now panel-icon-btn in header (see HTML)
-$('btnClearPreview').onclick=()=>{
-  $('previewArea').classList.remove('visible');
-  $('previewImg').src='';
-  $('previewMd').innerHTML='';
-  $('previewCode').textContent='';
-  $('previewPathText').textContent='';
-  $('fileTree').style.display='';
-};
+function clearPreview(){
+  const pa=$('previewArea');if(pa)pa.classList.remove('visible');
+  const pi=$('previewImg');if(pi){pi.onerror=null;pi.src='';}
+  const pm=$('previewMd');if(pm)pm.innerHTML='';
+  const pc=$('previewCode');if(pc)pc.textContent='';
+  const pp=$('previewPathText');if(pp)pp.textContent='';
+  const ft=$('fileTree');if(ft)ft.style.display='';
+  _previewCurrentPath='';_previewCurrentMode='';_previewDirty=false;
+}
+$('btnClearPreview').onclick=clearPreview;
 // workspacePath click handler removed -- use topbar workspace chip dropdown instead
 $('modelSelect').onchange=async()=>{
   if(!S.session)return;
@@ -59,8 +185,38 @@ $('modelSelect').onchange=async()=>{
   await api('/api/session/update',{method:'POST',body:JSON.stringify({session_id:S.session.session_id,workspace:S.session.workspace,model:selectedModel})});
   S.session.model=selectedModel;syncTopbar();
 };
-$('msg').addEventListener('input',autoResize);
-$('msg').addEventListener('keydown',e=>{if(e.key==='Enter'&&!e.shiftKey){e.preventDefault();send();}});
+$('msg').addEventListener('input',()=>{
+  autoResize();
+  updateSendBtn();
+  const text=$('msg').value;
+  if(text.startsWith('/')&&text.indexOf('\n')===-1){
+    const prefix=text.slice(1);
+    const matches=getMatchingCommands(prefix);
+    if(matches.length)showCmdDropdown(matches); else hideCmdDropdown();
+  } else {
+    hideCmdDropdown();
+  }
+});
+$('msg').addEventListener('keydown',e=>{
+  // Autocomplete navigation when dropdown is open
+  const dd=$('cmdDropdown');
+  const dropdownOpen=dd&&dd.classList.contains('open');
+  if(dropdownOpen){
+    if(e.key==='ArrowUp'){e.preventDefault();navigateCmdDropdown(-1);return;}
+    if(e.key==='ArrowDown'){e.preventDefault();navigateCmdDropdown(1);return;}
+    if(e.key==='Tab'){e.preventDefault();selectCmdDropdownItem();return;}
+    if(e.key==='Escape'){e.preventDefault();hideCmdDropdown();return;}
+    if(e.key==='Enter'&&!e.shiftKey){e.preventDefault();selectCmdDropdownItem();return;}
+  }
+  // Send key: respect user preference
+  if(e.key==='Enter'){
+    if(window._sendKey==='ctrl+enter'){
+      if(e.ctrlKey||e.metaKey){e.preventDefault();send();}
+    } else {
+      if(!e.shiftKey){e.preventDefault();send();}
+    }
+  }
+});
 // B14: Cmd/Ctrl+K creates a new chat from anywhere
 document.addEventListener('keydown',async e=>{
   if((e.metaKey||e.ctrlKey)&&e.key==='k'){
@@ -70,7 +226,7 @@ document.addEventListener('keydown',async e=>{
   if(e.key==='Escape'){
     // Close settings overlay if open
     const settingsOverlay=$('settingsOverlay');
-    if(settingsOverlay&&settingsOverlay.style.display!=='none'){toggleSettings();return;}
+    if(settingsOverlay&&settingsOverlay.style.display!=='none'){_closeSettingsPanel();return;}
     // Close workspace dropdown
     closeWsDropdown();
     // Clear session search
@@ -150,7 +306,35 @@ document.querySelectorAll('.suggestion').forEach(btn=>{
   };
 })();
 
+function applyBotName(){
+  const name=window._botName||'Hermes';
+  document.title=name;
+  const sidebarH1=document.querySelector('.sidebar-header h1');
+  if(sidebarH1) sidebarH1.textContent=name;
+  const logo=document.querySelector('.sidebar-header .logo');
+  if(logo) logo.textContent=name.charAt(0).toUpperCase();
+  const topbarTitle=$('topbarTitle');
+  if(topbarTitle && (!S.session)) topbarTitle.textContent=name;
+  const msg=$('msg');
+  if(msg) msg.placeholder='Message '+name+'\u2026';
+}
+
 (async()=>{
+  // Load send key preference
+  let _bootSettings={};
+  try{const s=await api('/api/settings');_bootSettings=s;window._sendKey=s.send_key||'enter';window._showTokenUsage=!!s.show_token_usage;window._showCliSessions=!!s.show_cli_sessions;window._botName=s.bot_name||'Hermes';const _theme=s.theme||'dark';document.documentElement.dataset.theme=_theme;localStorage.setItem('hermes-theme',_theme);applyBotName();}catch(e){window._sendKey='enter';window._showTokenUsage=false;window._showCliSessions=false;window._botName='Hermes';_bootSettings={check_for_updates:false};}
+  // Non-blocking update check (fire-and-forget, once per tab session)
+  // ?test_updates=1 in URL forces banner display for testing (bypasses sessionStorage guards)
+  const _testUpdates=new URLSearchParams(location.search).get('test_updates')==='1';
+  if(_testUpdates||(_bootSettings.check_for_updates!==false&&!sessionStorage.getItem('hermes-update-checked')&&!sessionStorage.getItem('hermes-update-dismissed'))){
+    const _checkUrl='/api/updates/check'+(_testUpdates?'?simulate=1':'');
+    api(_checkUrl).then(d=>{if(!_testUpdates)sessionStorage.setItem('hermes-update-checked','1');if((d.webui&&d.webui.behind>0)||(d.agent&&d.agent.behind>0))_showUpdateBanner(d);}).catch(()=>{});
+  }
+  // Fetch active profile
+  try{const p=await api('/api/profile/active');S.activeProfile=p.name||'default';}catch(e){S.activeProfile='default';}
+  // Update profile chip label immediately
+  const profileLabel=$('profileChipLabel');
+  if(profileLabel) profileLabel.textContent=S.activeProfile||'default';
   // Fetch available models from server and populate dropdown dynamically
   await populateModelDropdown();
   // Restore last-used model preference

static/commands.js

@@ -0,0 +1,228 @@
+// ── Slash commands ──────────────────────────────────────────────────────────
+// Built-in commands intercepted before send(). Each command runs locally
+// (no round-trip to the agent) and shows feedback via toast or local message.
+
+const COMMANDS=[
+  {name:'help',      desc:'List available commands',             fn:cmdHelp},
+  {name:'clear',     desc:'Clear conversation messages',         fn:cmdClear},
+  {name:'compact',   desc:'Compress conversation context',       fn:cmdCompact},
+  {name:'model',     desc:'Switch model (e.g. /model gpt-4o)',  fn:cmdModel,     arg:'model_name'},
+  {name:'workspace', desc:'Switch workspace by name',            fn:cmdWorkspace, arg:'name'},
+  {name:'new',       desc:'Start a new chat session',            fn:cmdNew},
+  {name:'usage',     desc:'Toggle token usage display on/off',   fn:cmdUsage},
+  {name:'theme',     desc:'Switch theme (dark/light/slate/solarized/monokai/nord)', fn:cmdTheme, arg:'name'},
+  {name:'personality', desc:'Switch agent personality', fn:cmdPersonality, arg:'name'},
+];
+
+function parseCommand(text){
+  if(!text.startsWith('/'))return null;
+  const parts=text.slice(1).split(/\s+/);
+  const name=parts[0].toLowerCase();
+  const args=parts.slice(1).join(' ').trim();
+  return {name,args};
+}
+
+function executeCommand(text){
+  const parsed=parseCommand(text);
+  if(!parsed)return false;
+  const cmd=COMMANDS.find(c=>c.name===parsed.name);
+  if(!cmd)return false;
+  cmd.fn(parsed.args);
+  return true;
+}
+
+function getMatchingCommands(prefix){
+  const q=prefix.toLowerCase();
+  return COMMANDS.filter(c=>c.name.startsWith(q));
+}
+
+// ── Command handlers ────────────────────────────────────────────────────────
+
+function cmdHelp(){
+  const lines=COMMANDS.map(c=>{
+    const usage=c.arg?` <${c.arg}>`:'';
+    return `  /${c.name}${usage} — ${c.desc}`;
+  });
+  const msg={role:'assistant',content:'**Available commands:**\n'+lines.join('\n')};
+  S.messages.push(msg);
+  renderMessages();
+  showToast('Type / to see commands');
+}
+
+function cmdClear(){
+  if(!S.session)return;
+  S.messages=[];S.toolCalls=[];
+  clearLiveToolCards();
+  renderMessages();
+  $('emptyState').style.display='';
+  showToast('Conversation cleared');
+}
+
+async function cmdModel(args){
+  if(!args){showToast('Usage: /model <name>');return;}
+  const sel=$('modelSelect');
+  if(!sel)return;
+  const q=args.toLowerCase();
+  // Fuzzy match: find first option whose label or value contains the query
+  let match=null;
+  for(const opt of sel.options){
+    if(opt.value.toLowerCase().includes(q)||opt.textContent.toLowerCase().includes(q)){
+      match=opt.value;break;
+    }
+  }
+  if(!match){showToast(`No model matching "${args}"`);return;}
+  sel.value=match;
+  await sel.onchange();
+  showToast(`Switched to ${match}`);
+}
+
+async function cmdWorkspace(args){
+  if(!args){showToast('Usage: /workspace <name>');return;}
+  try{
+    const data=await api('/api/workspaces');
+    const q=args.toLowerCase();
+    const ws=(data.workspaces||[]).find(w=>
+      (w.name||'').toLowerCase().includes(q)||w.path.toLowerCase().includes(q)
+    );
+    if(!ws){showToast(`No workspace matching "${args}"`);return;}
+    if(!S.session)return;
+    await api('/api/session/update',{method:'POST',body:JSON.stringify({
+      session_id:S.session.session_id,workspace:ws.path,model:S.session.model
+    })});
+    S.session.workspace=ws.path;
+    syncTopbar();await loadDir('.');
+    showToast(`Switched to workspace: ${ws.name||ws.path}`);
+  }catch(e){showToast('Workspace switch failed: '+e.message);}
+}
+
+async function cmdNew(){
+  await newSession();
+  await renderSessionList();
+  $('msg').focus();
+  showToast('New session created');
+}
+
+function cmdCompact(){
+  // Send as a regular message to the agent -- the agent's run_conversation
+  // preflight will detect the high token count and trigger _compress_context.
+  // We send a user message so it appears in the conversation.
+  $('msg').value='Please compress and summarize the conversation context to free up space.';
+  send();
+  showToast('Requesting context compression...');
+}
+
+async function cmdUsage(){
+  const next=!window._showTokenUsage;
+  window._showTokenUsage=next;
+  try{
+    await api('/api/settings',{method:'POST',body:JSON.stringify({show_token_usage:next})});
+  }catch(e){}
+  // Update the settings checkbox if the panel is open
+  const cb=$('settingsShowTokenUsage');
+  if(cb) cb.checked=next;
+  renderMessages();
+  showToast('Token usage '+(next?'on':'off'));
+}
+
+async function cmdTheme(args){
+  const themes=['dark','light','slate','solarized','monokai','nord'];
+  if(!args||!themes.includes(args.toLowerCase())){
+    showToast('Usage: /theme '+themes.join('|'));
+    return;
+  }
+  const t=args.toLowerCase();
+  document.documentElement.dataset.theme=t;
+  localStorage.setItem('hermes-theme',t);
+  try{await api('/api/settings',{method:'POST',body:JSON.stringify({theme:t})});}catch(e){}
+  // Update settings dropdown if panel is open
+  const sel=$('settingsTheme');
+  if(sel)sel.value=t;
+  showToast('Theme: '+t);
+}
+
+async function cmdPersonality(args){
+  if(!S.session){showToast('No active session');return;}
+  if(!args){
+    // List available personalities
+    try{
+      const data=await api('/api/personalities');
+      if(!data.personalities||!data.personalities.length){
+        showToast('No personalities found (add them to ~/.hermes/personalities/)');
+        return;
+      }
+      const list=data.personalities.map(p=>`  **${p.name}**${p.description?' — '+p.description:''}`).join('\n');
+      S.messages.push({role:'assistant',content:'Available personalities:\n\n'+list+'\n\nUse `/personality <name>` to switch, or `/personality none` to clear.'});
+      renderMessages();
+    }catch(e){showToast('Failed to load personalities');}
+    return;
+  }
+  const name=args.trim();
+  if(name.toLowerCase()==='none'||name.toLowerCase()==='default'||name.toLowerCase()==='clear'){
+    try{
+      await api('/api/personality/set',{method:'POST',body:JSON.stringify({session_id:S.session.session_id,name:''})});
+      showToast('Personality cleared');
+    }catch(e){showToast('Failed: '+e.message);}
+    return;
+  }
+  try{
+    const res=await api('/api/personality/set',{method:'POST',body:JSON.stringify({session_id:S.session.session_id,name})});
+    showToast('Personality: '+name);
+  }catch(e){showToast('Failed: '+e.message);}
+}
+
+// ── Autocomplete dropdown ───────────────────────────────────────────────────
+
+let _cmdSelectedIdx=-1;
+
+function showCmdDropdown(matches){
+  const dd=$('cmdDropdown');
+  if(!dd)return;
+  dd.innerHTML='';
+  _cmdSelectedIdx=-1;
+  for(let i=0;i<matches.length;i++){
+    const c=matches[i];
+    const el=document.createElement('div');
+    el.className='cmd-item';
+    el.dataset.idx=i;
+    const usage=c.arg?` <span class="cmd-item-arg">${esc(c.arg)}</span>`:'';
+    el.innerHTML=`<div class="cmd-item-name">/${esc(c.name)}${usage}</div><div class="cmd-item-desc">${esc(c.desc)}</div>`;
+    el.onmousedown=(e)=>{
+      e.preventDefault();
+      $('msg').value='/'+c.name+(c.arg?' ':'');
+      hideCmdDropdown();
+      $('msg').focus();
+    };
+    dd.appendChild(el);
+  }
+  dd.classList.add('open');
+}
+
+function hideCmdDropdown(){
+  const dd=$('cmdDropdown');
+  if(dd)dd.classList.remove('open');
+  _cmdSelectedIdx=-1;
+}
+
+function navigateCmdDropdown(dir){
+  const dd=$('cmdDropdown');
+  if(!dd)return;
+  const items=dd.querySelectorAll('.cmd-item');
+  if(!items.length)return;
+  items.forEach(el=>el.classList.remove('selected'));
+  _cmdSelectedIdx+=dir;
+  if(_cmdSelectedIdx<0)_cmdSelectedIdx=items.length-1;
+  if(_cmdSelectedIdx>=items.length)_cmdSelectedIdx=0;
+  items[_cmdSelectedIdx].classList.add('selected');
+}
+
+function selectCmdDropdownItem(){
+  const dd=$('cmdDropdown');
+  if(!dd)return;
+  const items=dd.querySelectorAll('.cmd-item');
+  if(_cmdSelectedIdx>=0&&_cmdSelectedIdx<items.length){
+    items[_cmdSelectedIdx].onmousedown({preventDefault:()=>{}});
+  } else if(items.length===1){
+    items[0].onmousedown({preventDefault:()=>{}});
+  }
+  hideCmdDropdown();
+}

static/index.html

@@ -4,22 +4,24 @@
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>Hermes</title>
+<script>(function(){var t=localStorage.getItem('hermes-theme');if(t&&t!=='dark')document.documentElement.dataset.theme=t;})()</script>
 <link rel="stylesheet" href="/static/style.css">
   <!-- Prism.js syntax highlighting (loaded async, non-blocking) -->
-  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/themes/prism-tomorrow.min.css">
-  <script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
-  <script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/themes/prism-tomorrow.min.css" integrity="sha384-wFjoQjtV1y5jVHbt0p35Ui8aV8GVpEZkyF99OXWqP/eNJDU93D3Ugxkoyh6Y2I4A" crossorigin="anonymous">
+  <script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" integrity="sha384-MXybTpajaBV0AkcBaCPT4KIvo0FzoCiWXgcihYsw4FUkEz0Pv3JGV6tk2G8vJtDc" crossorigin="anonymous" defer></script>
+  <script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" integrity="sha384-Uq05+JLko69eOiPr39ta9bh7kld5PKZoU+fF7g0EXTAriEollhZ+DrN8Q/Oi8J2Q" crossorigin="anonymous" defer></script>
 </head>
 <body>
 <div class="layout">
   <aside class="sidebar">
-    <div class="sidebar-header"><div class="logo">H</div><div><h1 style="margin:0;font-size:15px;font-weight:700;letter-spacing:-.01em">Hermes</h1><div style="font-size:10px;color:var(--muted);opacity:.8;margin-top:1px">v0.2</div></div></div>
+    <div class="sidebar-header"><div class="logo">H</div><div><h1 style="margin:0;font-size:15px;font-weight:700;letter-spacing:-.01em">Hermes</h1><div style="font-size:10px;color:var(--muted);opacity:.8;margin-top:1px">v0.38.4</div></div></div>
     <div class="sidebar-nav">
       <button class="nav-tab active" data-panel="chat" data-label="Chat" onclick="switchPanel('chat')" title="Chat">&#128172;</button>
       <button class="nav-tab" data-panel="tasks" data-label="Tasks" onclick="switchPanel('tasks')" title="Tasks">&#128197;</button>
       <button class="nav-tab" data-panel="skills" data-label="Skills" onclick="switchPanel('skills')" title="Skills">&#129513;</button>
       <button class="nav-tab" data-panel="memory" data-label="Memory" onclick="switchPanel('memory')" title="Memory">&#129504;</button>
       <button class="nav-tab" data-panel="workspaces" data-label="Spaces" onclick="switchPanel('workspaces')" title="Spaces">&#128193;</button>
+      <button class="nav-tab" data-panel="profiles" data-label="Profiles" onclick="switchPanel('profiles')" title="Agent profiles"><svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2"/><circle cx="12" cy="7" r="4"/></svg></button>
       <button class="nav-tab" data-panel="todos" data-label="Todos" onclick="switchPanel('todos')" title="Current task list">&#9989;</button>
     </div>
     <!-- Chat panel -->
@@ -44,11 +46,16 @@
         <input id="cronFormName" placeholder="Job name (optional)" style="width:100%;background:rgba(255,255,255,.05);border:1px solid var(--border2);border-radius:6px;color:var(--text);padding:5px 8px;font-size:12px;outline:none;margin-bottom:6px">
         <input id="cronFormSchedule" placeholder="Schedule: '0 9 * * *' or 'every 1h'" style="width:100%;background:rgba(255,255,255,.05);border:1px solid var(--border2);border-radius:6px;color:var(--text);padding:5px 8px;font-size:12px;outline:none;margin-bottom:6px">
         <textarea id="cronFormPrompt" rows="3" placeholder="Prompt (must be self-contained)" style="width:100%;background:rgba(255,255,255,.05);border:1px solid var(--border2);border-radius:6px;color:var(--text);padding:5px 8px;font-size:12px;outline:none;resize:none;font-family:inherit;margin-bottom:6px"></textarea>
-        <select id="cronFormDeliver" style="width:100%;background:rgba(255,255,255,.05);border:1px solid var(--border2);border-radius:6px;color:var(--text);padding:5px 8px;font-size:12px;outline:none;margin-bottom:8px">
+        <select id="cronFormDeliver" style="width:100%;background:rgba(255,255,255,.05);border:1px solid var(--border2);border-radius:6px;color:var(--text);padding:5px 8px;font-size:12px;outline:none;margin-bottom:6px">
           <option value="local">Local (save output only)</option>
           <option value="discord">Discord</option>
           <option value="telegram">Telegram</option>
         </select>
+        <div class="skill-picker-wrap" style="margin-bottom:8px">
+          <input id="cronFormSkillSearch" placeholder="Add skills (optional)..." style="width:100%;background:rgba(255,255,255,.05);border:1px solid var(--border2);border-radius:6px;color:var(--text);padding:5px 8px;font-size:12px;outline:none" autocomplete="off">
+          <div id="cronFormSkillDropdown" class="skill-picker-dropdown" style="display:none"></div>
+          <div id="cronFormSkillTags" class="skill-picker-tags"></div>
+        </div>
         <div style="display:flex;gap:6px">
           <button class="cron-btn run" style="flex:1" onclick="submitCronCreate()">Create job</button>
           <button class="cron-btn" style="flex:1" onclick="toggleCronForm()">Cancel</button>
@@ -104,6 +111,26 @@
       <div style="padding:10px 12px 4px;font-size:11px;color:var(--muted)">Add and switch workspaces for your sessions.</div>
       <div style="flex:1;overflow-y:auto;padding:0 12px 12px" id="workspacesPanel"><div style="color:var(--muted);font-size:12px">Loading...</div></div>
     </div>
+    <!-- Profiles panel -->
+    <div class="panel-view" id="panelProfiles">
+      <div class="sidebar-section" style="padding-bottom:4px;display:flex;align-items:center;justify-content:space-between">
+        <div style="font-size:11px;color:var(--muted)">Agent profiles</div>
+        <button class="cron-btn run" style="padding:3px 8px;font-size:10px" onclick="toggleProfileForm()">+ New profile</button>
+      </div>
+      <!-- Profile create form (hidden by default) -->
+      <div id="profileCreateForm" style="display:none;padding:8px 12px;border-bottom:1px solid var(--border);flex-shrink:0">
+        <input id="profileFormName" placeholder="Profile name (lowercase, a-z 0-9 hyphens)" style="width:100%;background:rgba(255,255,255,.05);border:1px solid var(--border2);border-radius:6px;color:var(--text);padding:5px 8px;font-size:12px;outline:none;margin-bottom:6px;box-sizing:border-box">
+        <label style="display:flex;align-items:center;gap:6px;font-size:11px;color:var(--muted);margin-bottom:8px;cursor:pointer">
+          <input type="checkbox" id="profileFormClone" style="accent-color:var(--accent)"> Clone config from active profile
+        </label>
+        <div style="display:flex;gap:6px">
+          <button class="cron-btn run" style="flex:1" onclick="submitProfileCreate()">Create</button>
+          <button class="cron-btn" style="flex:1" onclick="toggleProfileForm()">Cancel</button>
+        </div>
+        <div id="profileFormError" style="font-size:11px;color:var(--accent);margin-top:6px;display:none"></div>
+      </div>
+      <div style="flex:1;overflow-y:auto;padding:0 12px 12px" id="profilesPanel"><div style="color:var(--muted);font-size:12px">Loading...</div></div>
+    </div>
     <div class="sidebar-bottom">
       <div class="field-label" style="font-size:10px;letter-spacing:.07em;margin-bottom:4px">MODEL</div>
       <select id="modelSelect">
@@ -124,13 +151,16 @@
           <option value="meta-llama/llama-4-scout">Llama 4 Scout</option>
         </optgroup>
       </select>
-      <div id="sidebarWsDisplay" style="display:flex;align-items:center;gap:7px;padding:0 0 8px;cursor:pointer;border-radius:8px;transition:background .15s" onclick="toggleWsDropdown()" title="Switch workspace">
-        <span style="font-size:14px;opacity:.7">&#128193;</span>
-        <div style="min-width:0;flex:1">
-          <div style="font-size:11px;font-weight:600;color:var(--text);overflow:hidden;text-overflow:ellipsis;white-space:nowrap" id="sidebarWsName">Workspace</div>
-          <div style="font-size:10px;color:var(--muted);overflow:hidden;text-overflow:ellipsis;white-space:nowrap;margin-top:1px" id="sidebarWsPath"></div>
+      <div style="position:relative">
+        <div id="sidebarWsDisplay" style="display:flex;align-items:center;gap:7px;padding:0 0 8px;cursor:pointer;border-radius:8px;transition:background .15s" onclick="toggleWsDropdown()" title="Switch workspace">
+          <span style="font-size:14px;opacity:.7">&#128193;</span>
+          <div style="min-width:0;flex:1">
+            <div style="font-size:11px;font-weight:600;color:var(--text);overflow:hidden;text-overflow:ellipsis;white-space:nowrap" id="sidebarWsName">Workspace</div>
+            <div style="font-size:10px;color:var(--muted);overflow:hidden;text-overflow:ellipsis;white-space:nowrap;margin-top:1px" id="sidebarWsPath"></div>
+          </div>
+          <span style="font-size:10px;color:var(--muted);flex-shrink:0">&#9662;</span>
         </div>
-        <span style="font-size:10px;color:var(--muted);flex-shrink:0">&#9662;</span>
+        <div class="ws-dropdown" id="wsDropdown"></div>
       </div>
       <div class="sidebar-actions">
         <button class="sm-btn" id="btnDownload" title="Download as Markdown">&#8595; Transcript</button>
@@ -143,15 +173,20 @@
   </aside>
   <main class="main">
     <div class="topbar">
+      <button class="mobile-hamburger" id="btnHamburger" onclick="toggleMobileSidebar()" title="Menu">
+        <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="3" y1="6" x2="21" y2="6"/><line x1="3" y1="12" x2="21" y2="12"/><line x1="3" y1="18" x2="21" y2="18"/></svg>
+      </button>
       <div style="flex:1;min-width:0;overflow:hidden"><div class="topbar-title" id="topbarTitle">Hermes</div><div class="topbar-meta" id="topbarMeta">Start a new conversation</div></div>
       <div class="topbar-chips">
-        <div class="chip model" id="modelChip">GPT-5.4 Mini</div>
-        <div id="wsChipWrap" style="position:relative">
-          <div class="chip ws-chip" id="wsChip" onclick="toggleWsDropdown()" title="Switch workspace" style="cursor:pointer">&#128193; test-workspace &#9662;</div>
-          <div class="ws-dropdown" id="wsDropdown"></div>
+        <div id="profileChipWrap" style="position:relative">
+          <div class="chip profile-chip" id="profileChip" onclick="toggleProfileDropdown()" title="Switch profile" style="cursor:pointer"><svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" style="vertical-align:-1px;margin-right:3px"><path d="M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2"/><circle cx="12" cy="7" r="4"/></svg><span id="profileChipLabel">default</span> &#9662;</div>
+          <div class="profile-dropdown" id="profileDropdown"></div>
         </div>
+        <div class="chip model" id="modelChip">GPT-5.4 Mini</div>
+
         <button class="chip clear-btn" id="btnClearConv" onclick="clearConversation()" title="Clear all messages in this conversation" style="display:none">&#128465; Clear</button>
         <button class="chip gear-btn" id="btnSettings" onclick="toggleSettings()" title="Settings">&#9881;</button>
+        <button class="chip mobile-files-btn" id="btnMobileFiles" onclick="toggleMobileFiles()" title="Files">&#128193;</button>
       </div>
     </div>
     <div class="messages" id="messages">
@@ -168,6 +203,13 @@
       <div class="messages-inner" id="msgInner"></div>
       <div id="liveToolCards" style="display:none;max-width:800px;margin:0 auto;width:100%;padding:0 24px;"></div>
     </div>
+    <div class="update-banner" id="updateBanner">
+      <span id="updateMsg"></span>
+      <div style="display:flex;gap:8px;flex-shrink:0">
+        <button class="update-btn" onclick="dismissUpdate()">Later</button>
+        <button class="update-btn update-primary" id="btnApplyUpdate" onclick="applyUpdates()">Update Now</button>
+      </div>
+    </div>
     <div class="reconnect-banner" id="reconnectBanner">
       <span id="reconnectMsg">&#9888; A response may have been in progress when you last left. Reload messages?</span>
       <div style="display:flex;gap:8px;flex-shrink:0">
@@ -206,12 +248,14 @@
       </div>
     </div>
     <div class="composer-wrap" id="composerWrap">
+      <div class="cmd-dropdown" id="cmdDropdown"></div>
       <div class="composer-box" id="composerBox">
         <div class="drop-hint" id="dropHint">
           <svg width="28" height="28" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline points="17 8 12 3 7 8"/><line x1="12" y1="3" x2="12" y2="15"/></svg>
           Drop files to upload to workspace
         </div>
         <div class="attach-tray" id="attachTray"></div>
+        <div class="mic-status" id="micStatus" style="display:none"><span class="mic-dot"></span> Listening…</div>
         <textarea id="msg" rows="1" placeholder="Message Hermes…"></textarea>
         <div class="composer-footer">
           <div class="composer-left">
@@ -219,11 +263,22 @@
             <button class="icon-btn" id="btnAttach" title="Attach files">
               <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21.44 11.05l-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48"/></svg>
             </button>
+            <button class="icon-btn mic-btn" id="btnMic" title="Voice input" style="display:none">
+              <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                <rect x="9" y="1" width="6" height="12" rx="3"/>
+                <path d="M5 10a7 7 0 0 0 14 0"/>
+                <line x1="12" y1="19" x2="12" y2="23"/>
+                <line x1="8" y1="23" x2="16" y2="23"/>
+              </svg>
+            </button>
+          </div>
+          <div class="ctx-indicator" id="ctxIndicator" style="display:none" title="Context window usage">
+            <span class="ctx-bar-wrap"><span class="ctx-bar" id="ctxBar"></span></span>
+            <span class="ctx-label" id="ctxLabel"></span>
           </div>
           <div class="composer-right">
-            <button class="send-btn" id="btnSend">
-              <svg width="14" height="14" viewBox="0 0 24 24" fill="currentColor"><path d="M2.01 21L23 12 2.01 3 2 10l15 2-15 2z"/></svg>
-              Send
+            <button class="send-btn" id="btnSend" title="Send message" style="display:none">
+              <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><line x1="12" y1="19" x2="12" y2="5"/><polyline points="5 12 12 5 19 12"/></svg>
             </button>
           </div>
         </div>
@@ -235,13 +290,16 @@
     <div class="resize-handle" id="rightpanelResize"></div>
     <div class="panel-header">
       <span>Workspace</span>
+      <span class="git-badge" id="gitBadge" style="display:none"></span>
       <div class="panel-actions">
+        <button class="panel-icon-btn" id="btnUpDir" title="Parent directory" onclick="navigateUp()" style="display:none">&#8593;</button>
         <button class="panel-icon-btn" id="btnNewFile" title="New file" onclick="promptNewFile()">&#43;</button>
         <button class="panel-icon-btn" id="btnNewFolder" title="New folder" onclick="promptNewFolder()">&#128193;</button>
-        <button class="panel-icon-btn" id="btnRefreshPanel" title="Refresh" onclick="if(S.session)loadDir('.')">&#8635;</button>
+        <button class="panel-icon-btn" id="btnRefreshPanel" title="Refresh" onclick="if(S.session)loadDir(S.currentDir)">&#8635;</button>
         <button class="panel-icon-btn close-preview" id="btnClearPreview" title="Close preview">&#10005;</button>
       </div>
     </div>
+    <div class="breadcrumb-bar" id="breadcrumbBar" style="display:none"></div>
     <div class="file-tree" id="fileTree"></div>
     <div class="preview-area" id="previewArea">
       <div class="preview-path" id="previewPath">
@@ -261,7 +319,7 @@
   <div class="settings-panel">
     <div class="settings-header">
       <h3 style="margin:0;font-size:16px">Settings</h3>
-      <button class="panel-icon-btn" onclick="toggleSettings()" title="Close">&#10005;</button>
+      <button class="panel-icon-btn" onclick="_closeSettingsPanel()" title="Close">&#10005;</button>
     </div>
     <div class="settings-body">
       <div class="settings-field">
@@ -269,17 +327,95 @@
         <select id="settingsModel" style="width:100%;padding:8px;background:var(--code-bg);color:var(--text);border:1px solid var(--border2);border-radius:6px"></select>
       </div>
       <div class="settings-field">
-        <label for="settingsWorkspace">Default Workspace</label>
-        <select id="settingsWorkspace" style="width:100%;padding:8px;background:var(--code-bg);color:var(--text);border:1px solid var(--border2);border-radius:6px"></select>
+        <label for="settingsSendKey">Send Key</label>
+        <select id="settingsSendKey" style="width:100%;padding:8px;background:var(--code-bg);color:var(--text);border:1px solid var(--border2);border-radius:6px">
+          <option value="enter">Enter (Shift+Enter for newline)</option>
+          <option value="ctrl+enter">Ctrl+Enter (Enter for newline)</option>
+        </select>
+      </div>
+      <div class="settings-field">
+        <label for="settingsTheme">Theme</label>
+        <select id="settingsTheme" style="width:100%;padding:8px;background:var(--code-bg);color:var(--text);border:1px solid var(--border2);border-radius:6px" onchange="document.documentElement.dataset.theme=this.value;localStorage.setItem('hermes-theme',this.value)">
+          <option value="dark">Dark (default)</option>
+          <option value="light">Light</option>
+          <option value="slate">Slate (charcoal)</option>
+          <option value="solarized">Solarized Dark</option>
+          <option value="monokai">Monokai</option>
+          <option value="nord">Nord</option>
+        </select>
+      </div>
+      <div class="settings-field">
+        <label style="display:flex;align-items:center;gap:8px;cursor:pointer">
+          <input type="checkbox" id="settingsShowTokenUsage" style="width:15px;height:15px;accent-color:var(--accent)">
+          Show token usage after responses
+        </label>
+        <div style="font-size:11px;color:var(--muted);margin-top:4px">Displays input/output token count below each assistant reply. Also toggled with <code>/usage</code>.</div>
+      </div>
+      <div class="settings-field">
+        <label style="display:flex;align-items:center;gap:8px;cursor:pointer">
+          <input type="checkbox" id="settingsShowCliSessions" style="width:15px;height:15px;accent-color:var(--accent)">
+          Show CLI sessions in sidebar
+        </label>
+        <div style="font-size:11px;color:var(--muted);margin-top:4px">Merges sessions from the Hermes CLI (state.db) into the session list. Click a CLI session to import it and continue the conversation.</div>
+      </div>
+      <div class="settings-field">
+        <label style="display:flex;align-items:center;gap:8px;cursor:pointer">
+          <input type="checkbox" id="settingsSyncInsights" style="width:15px;height:15px;accent-color:var(--accent)">
+          Sync usage to /insights
+        </label>
+        <div style="font-size:11px;color:var(--muted);margin-top:4px">Mirrors WebUI token usage to state.db so <code>hermes /insights</code> includes browser session data. Off by default.</div>
+      </div>
+      <div class="settings-field">
+        <label style="display:flex;align-items:center;gap:8px;cursor:pointer">
+          <input type="checkbox" id="settingsCheckUpdates" style="width:15px;height:15px;accent-color:var(--accent)">
+          Check for updates
+        </label>
+        <div style="font-size:11px;color:var(--muted);margin-top:4px">Show a banner when newer versions of the WebUI or Agent are available. Runs a background git fetch periodically.</div>
+      </div>
+      <div class="settings-field">
+        <label for="settingsBotName">Assistant Name</label>
+        <div style="font-size:11px;color:var(--muted);margin-bottom:6px">Display name for the assistant throughout the UI. Defaults to Hermes.</div>
+        <input type="text" id="settingsBotName" placeholder="Hermes" maxlength="64" style="width:100%;padding:8px;background:var(--code-bg);color:var(--text);border:1px solid var(--border2);border-radius:6px;font-size:13px">
+      </div>
+      <div class="settings-field" style="border-top:1px solid var(--border);padding-top:12px;margin-top:8px">
+        <label for="settingsPassword">Access Password</label>
+        <div style="font-size:11px;color:var(--muted);margin-bottom:6px">Enter a new password to set or change it. Leave blank to keep current setting.</div>
+        <input type="password" id="settingsPassword" placeholder="Enter new password…" style="width:100%;padding:8px;background:var(--code-bg);color:var(--text);border:1px solid var(--border2);border-radius:6px;font-size:13px">
       </div>
       <button class="sm-btn" onclick="saveSettings()" style="margin-top:12px;width:100%;padding:8px;font-weight:600">Save Settings</button>
+      <button class="sm-btn" id="btnDisableAuth" onclick="disableAuth()" style="margin-top:6px;width:100%;padding:8px;font-weight:600;color:#e8a030;border-color:rgba(232,160,48,.3);display:none">Disable Auth</button>
+      <button class="sm-btn" id="btnSignOut" onclick="signOut()" style="margin-top:6px;width:100%;padding:8px;font-weight:600;color:var(--accent);border-color:rgba(233,69,96,.3);display:none">Sign Out</button>
     </div>
   </div>
 </div>
+<div class="mobile-overlay" id="mobileOverlay" onclick="closeMobileSidebar()"></div>
+<nav class="mobile-bottom-nav" id="mobileBottomNav">
+  <button class="mobile-nav-btn active" data-panel="chat" onclick="mobileSwitchPanel('chat')">
+    <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"/></svg>
+    <span>Chat</span>
+  </button>
+  <button class="mobile-nav-btn" data-panel="tasks" onclick="mobileSwitchPanel('tasks')">
+    <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><rect x="3" y="4" width="18" height="18" rx="2"/><line x1="16" y1="2" x2="16" y2="6"/><line x1="8" y1="2" x2="8" y2="6"/><line x1="3" y1="10" x2="21" y2="10"/></svg>
+    <span>Tasks</span>
+  </button>
+  <button class="mobile-nav-btn" data-panel="skills" onclick="mobileSwitchPanel('skills')">
+    <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M12 2L2 7l10 5 10-5-10-5z"/><path d="M2 17l10 5 10-5"/><path d="M2 12l10 5 10-5"/></svg>
+    <span>Skills</span>
+  </button>
+  <button class="mobile-nav-btn" data-panel="memory" onclick="mobileSwitchPanel('memory')">
+    <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M12 2a7 7 0 0 1 7 7c0 2.5-1.3 4.7-3.2 6H8.2C6.3 13.7 5 11.5 5 9a7 7 0 0 1 7-7z"/><line x1="9" y1="17" x2="15" y2="17"/><line x1="10" y1="20" x2="14" y2="20"/></svg>
+    <span>Memory</span>
+  </button>
+  <button class="mobile-nav-btn" data-panel="workspaces" onclick="mobileSwitchPanel('workspaces')">
+    <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M2 4h8l2 2h10v14H2z"/></svg>
+    <span>Spaces</span>
+  </button>
+</nav>
 <div class="toast" id="toast"></div>
 <script src="/static/ui.js"></script>
 <script src="/static/workspace.js"></script>
 <script src="/static/sessions.js"></script>
+<script src="/static/commands.js"></script>
 <script src="/static/messages.js"></script>
 <script src="/static/panels.js"></script>
 <script src="/static/boot.js"></script>

static/messages.js

@@ -1,6 +1,10 @@
 async function send(){
   const text=$('msg').value.trim();
   if(!text&&!S.pendingFiles.length)return;
+  // Slash command intercept -- local commands handled without agent round-trip
+  if(text.startsWith('/')&&!S.pendingFiles.length&&executeCommand(text)){
+    $('msg').value='';autoResize();hideCmdDropdown();return;
+  }
   // Don't send while an inline message edit is active
   if(document.querySelector('.msg-edit-area'))return;
   // If busy, queue the message instead of dropping it
@@ -89,8 +93,9 @@ async function send(){
     assistantRow=document.createElement('div');assistantRow.className='msg-row';
     assistantBody=document.createElement('div');assistantBody.className='msg-body';
     const role=document.createElement('div');role.className='msg-role assistant';
-    const icon=document.createElement('div');icon.className='role-icon assistant';icon.textContent='H';
-    const lbl=document.createElement('span');lbl.style.fontSize='12px';lbl.textContent='Hermes';
+    const _bn=window._botName||'Hermes';
+    const icon=document.createElement('div');icon.className='role-icon assistant';icon.textContent=_bn.charAt(0).toUpperCase();
+    const lbl=document.createElement('span');lbl.style.fontSize='12px';lbl.textContent=_bn;
     role.appendChild(icon);role.appendChild(lbl);
     assistantRow.appendChild(role);assistantRow.appendChild(assistantBody);
     $('msgInner').appendChild(assistantRow);
@@ -99,14 +104,25 @@ async function send(){
   // ── Shared SSE handler wiring (used for initial connection and reconnect) ──
   let _reconnectAttempted=false;
 
+  // rAF-throttled rendering: buffer tokens, render at most once per frame
+  let _renderPending=false;
+  function _scheduleRender(){
+    if(_renderPending) return;
+    _renderPending=true;
+    requestAnimationFrame(()=>{
+      _renderPending=false;
+      if(assistantBody) assistantBody.innerHTML=renderMd(assistantText);
+      scrollIfPinned();
+    });
+  }
+
   function _wireSSE(source){
     source.addEventListener('token',e=>{
       if(!S.session||S.session.session_id!==activeSid) return;
       const d=JSON.parse(e.data);
       assistantText+=d.text;
       ensureAssistantRow();
-      assistantBody.innerHTML=renderMd(assistantText);
-      scrollIfPinned();
+      _scheduleRender();
     });
 
     source.addEventListener('tool',e=>{
@@ -142,6 +158,10 @@ async function send(){
       }
       if(S.session&&S.session.session_id===activeSid){
         S.session=d.session;S.messages=d.session.messages||[];
+        // Stamp _ts on the last assistant message if it has no timestamp
+        const lastAsst=[...S.messages].reverse().find(m=>m.role==='assistant');
+        if(lastAsst&&!lastAsst._ts&&!lastAsst.timestamp) lastAsst._ts=Date.now()/1000;
+        if(d.usage){S.lastUsage=d.usage;_syncCtxIndicator(d.usage);}
         if(d.session.tool_calls&&d.session.tool_calls.length){
           S.toolCalls=d.session.tool_calls.map(tc=>({...tc,done:true}));
         } else {
@@ -158,6 +178,57 @@ async function send(){
       renderSessionList();setBusy(false);setStatus('');
     });
 
+    source.addEventListener('compressed',e=>{
+      // Context was auto-compressed during this turn -- show a system message
+      if(!S.session||S.session.session_id!==activeSid) return;
+      try{
+        const d=JSON.parse(e.data);
+        const sysMsg={role:'assistant',content:'*[Context was auto-compressed to continue the conversation]*'};
+        S.messages.push(sysMsg);
+        showToast(d.message||'Context compressed');
+      }catch(err){}
+    });
+
+    source.addEventListener('apperror',e=>{
+      // Application-level error sent explicitly by the server (rate limit, crash, etc.)
+      // This is distinct from the SSE network 'error' event below.
+      source.close();
+      delete INFLIGHT[activeSid];clearInflight();stopApprovalPolling();
+      if(!_approvalSessionId||_approvalSessionId===activeSid) hideApprovalCard();
+      if(S.session&&S.session.session_id===activeSid){
+        S.activeStreamId=null;const _cbe=$('btnCancel');if(_cbe)_cbe.style.display='none';
+        clearLiveToolCards();if(!assistantText)removeThinking();
+        try{
+          const d=JSON.parse(e.data);
+          const isRateLimit=d.type==='rate_limit';
+          const icon=isRateLimit?'⏱️':'⚠️';
+          const label=isRateLimit?'Rate limit reached':'Error';
+          const hint=d.hint?`\n\n*${d.hint}*`:'';
+          S.messages.push({role:'assistant',content:`**${icon} ${label}:** ${d.message}${hint}`});
+        }catch(_){
+          S.messages.push({role:'assistant',content:'**⚠️ Error:** An error occurred. Check server logs.'});
+        }
+        renderMessages();
+      }else if(typeof trackBackgroundError==='function'){
+        const _errTitle=(typeof _allSessions!=='undefined'&&_allSessions.find(s=>s.session_id===activeSid)||{}).title||null;
+        try{const d=JSON.parse(e.data);trackBackgroundError(activeSid,_errTitle,d.message||'Error');}
+        catch(_){trackBackgroundError(activeSid,_errTitle,'Error');}
+      }
+      if(!S.session||!INFLIGHT[S.session.session_id]){setBusy(false);setStatus('');}
+    });
+
+    source.addEventListener('warning',e=>{
+      // Non-fatal warning from server (e.g. fallback activated, retrying)
+      if(!S.session||S.session.session_id!==activeSid) return;
+      try{
+        const d=JSON.parse(e.data);
+        // Show as a small inline notice, not a full error
+        setStatus(`⚠️ ${d.message||'Warning'}`);
+        // If it's a fallback notice, show it briefly then clear
+        if(d.type==='fallback') setTimeout(()=>setStatus(''),4000);
+      }catch(_){}
+    });
+
     source.addEventListener('error',e=>{
       source.close();
       // Attempt one reconnect if the stream is still active server-side
@@ -169,7 +240,7 @@ async function send(){
             const st=await api(`/api/chat/stream/status?stream_id=${encodeURIComponent(streamId)}`);
             if(st.active){
               setStatus('Reconnected');
-              _wireSSE(new EventSource(`/api/chat/stream?stream_id=${encodeURIComponent(streamId)}`));
+              _wireSSE(new EventSource(new URL(`/api/chat/stream?stream_id=${encodeURIComponent(streamId)}`,location.origin).href,{withCredentials:true}));
               return;
             }
           }catch(_){}
@@ -214,7 +285,7 @@ async function send(){
     if(!S.session||!INFLIGHT[S.session.session_id]){setBusy(false);setStatus('Error: Connection lost');}
   }
 
-  _wireSSE(new EventSource(`/api/chat/stream?stream_id=${encodeURIComponent(streamId)}`));
+  _wireSSE(new EventSource(new URL(`/api/chat/stream?stream_id=${encodeURIComponent(streamId)}`,location.origin).href,{withCredentials:true}));
 
 }
 
@@ -233,7 +304,7 @@ function transcript(){
   return lines.join('\n');
 }
 
-function autoResize(){const el=$('msg');el.style.height='auto';el.style.height=Math.min(el.scrollHeight,200)+'px';}
+function autoResize(){const el=$('msg');el.style.height='auto';el.style.height=Math.min(el.scrollHeight,200)+'px';updateSendBtn();}
 
 
 // ── Approval polling ──

static/panels.js

@@ -14,6 +14,7 @@ async function switchPanel(name) {
   if (name === 'skills') await loadSkills();
   if (name === 'memory') await loadMemory();
   if (name === 'workspaces') await loadWorkspacesPanel();
+  if (name === 'profiles') await loadProfilesPanel();
   if (name === 'todos') loadTodos();
 }
 
@@ -78,6 +79,9 @@ async function loadCrons() {
   } catch(e) { box.innerHTML = `<div style="padding:12px;color:var(--accent);font-size:12px">Error: ${esc(e.message)}</div>`; }
 }
 
+let _cronSelectedSkills=[];
+let _cronSkillsCache=null;
+
 function toggleCronForm(){
   const form=$('cronCreateForm');
   if(!form)return;
@@ -89,10 +93,70 @@ function toggleCronForm(){
     $('cronFormPrompt').value='';
     $('cronFormDeliver').value='local';
     $('cronFormError').style.display='none';
+    _cronSelectedSkills=[];
+    _renderCronSkillTags();
+    const search=$('cronFormSkillSearch');
+    if(search)search.value='';
+    // Pre-fetch skills for the picker
+    if(!_cronSkillsCache){
+      api('/api/skills').then(d=>{_cronSkillsCache=d.skills||[];}).catch(()=>{});
+    }
     $('cronFormName').focus();
   }
 }
 
+function _renderCronSkillTags(){
+  const wrap=$('cronFormSkillTags');
+  if(!wrap)return;
+  wrap.innerHTML='';
+  for(const name of _cronSelectedSkills){
+    const tag=document.createElement('span');
+    tag.className='skill-tag';
+    tag.dataset.skill=name;
+    const rm=document.createElement('span');
+    rm.className='remove-tag';rm.textContent='×';
+    rm.onclick=()=>{_cronSelectedSkills=_cronSelectedSkills.filter(s=>s!==name);tag.remove();};
+    tag.appendChild(document.createTextNode(name));
+    tag.appendChild(rm);
+    wrap.appendChild(tag);
+  }
+}
+
+// Skill search input handler
+(function(){
+  const setup=()=>{
+    const search=$('cronFormSkillSearch');
+    const dropdown=$('cronFormSkillDropdown');
+    if(!search||!dropdown)return;
+    search.oninput=()=>{
+      const q=search.value.trim().toLowerCase();
+      if(!q||!_cronSkillsCache){dropdown.style.display='none';return;}
+      const matches=_cronSkillsCache.filter(s=>
+        !_cronSelectedSkills.includes(s.name)&&
+        (s.name.toLowerCase().includes(q)||(s.category||'').toLowerCase().includes(q))
+      ).slice(0,8);
+      if(!matches.length){dropdown.style.display='none';return;}
+      dropdown.innerHTML='';
+      for(const s of matches){
+        const opt=document.createElement('div');
+        opt.className='skill-opt';
+        opt.textContent=s.name+(s.category?' ('+s.category+')':'');
+        opt.onclick=()=>{
+          _cronSelectedSkills.push(s.name);
+          _renderCronSkillTags();
+          search.value='';
+          dropdown.style.display='none';
+        };
+        dropdown.appendChild(opt);
+      }
+      dropdown.style.display='';
+    };
+    search.onblur=()=>setTimeout(()=>{dropdown.style.display='none';},150);
+  };
+  if(document.readyState==='loading')document.addEventListener('DOMContentLoaded',setup);
+  else setTimeout(setup,0);
+})();
+
 async function submitCronCreate(){
   const name=$('cronFormName').value.trim();
   const schedule=$('cronFormSchedule').value.trim();
@@ -103,7 +167,10 @@ async function submitCronCreate(){
   if(!schedule){errEl.textContent='Schedule is required (e.g. "0 9 * * *" or "every 1h")';errEl.style.display='';return;}
   if(!prompt){errEl.textContent='Prompt is required';errEl.style.display='';return;}
   try{
-    await api('/api/crons/create',{method:'POST',body:JSON.stringify({name:name||undefined,schedule,prompt,deliver})});
+    const body={schedule,prompt,deliver};
+    if(name)body.name=name;
+    if(_cronSelectedSkills.length)body.skills=_cronSelectedSkills;
+    await api('/api/crons/create',{method:'POST',body:JSON.stringify(body)});
     toggleCronForm();
     showToast('Job created ✓');
     await loadCrons();
@@ -343,12 +410,49 @@ async function openSkill(name, el) {
     $('previewBadge').textContent = 'skill';
     $('previewBadge').className = 'preview-badge md';
     showPreview('md');
-    $('previewMd').innerHTML = renderMd(data.content || '(no content)');
+    let html = renderMd(data.content || '(no content)');
+    // Render linked files section if present
+    const lf = data.linked_files || {};
+    const categories = Object.entries(lf).filter(([,files]) => files && files.length > 0);
+    if (categories.length) {
+      html += '<div class="skill-linked-files"><div style="font-size:11px;font-weight:600;color:var(--muted);text-transform:uppercase;letter-spacing:.05em;margin-bottom:8px">Linked Files</div>';
+      for (const [cat, files] of categories) {
+        html += `<div class="skill-linked-section"><h4>${esc(cat)}</h4>`;
+        for (const f of files) {
+          html += `<a class="skill-linked-file" href="#" data-skill-name="${esc(name)}" data-skill-file="${esc(f)}">${esc(f)}</a>`;
+        }
+        html += '</div>';
+      }
+      html += '</div>';
+    }
+    $('previewMd').innerHTML = html;
+    // Wire linked-file clicks via data attributes (avoids inline JS XSS with apostrophes)
+    $('previewMd').querySelectorAll('.skill-linked-file').forEach(a=>{
+      a.addEventListener('click',e=>{e.preventDefault();openSkillFile(a.dataset.skillName,a.dataset.skillFile);});
+    });
     $('previewArea').classList.add('visible');
     $('fileTree').style.display = 'none';
   } catch(e) { setStatus('Could not load skill: ' + e.message); }
 }
 
+async function openSkillFile(skillName, filePath) {
+  try {
+    const data = await api(`/api/skills/content?name=${encodeURIComponent(skillName)}&file=${encodeURIComponent(filePath)}`);
+    $('previewPathText').textContent = skillName + ' / ' + filePath;
+    $('previewBadge').textContent = filePath.split('.').pop() || 'file';
+    $('previewBadge').className = 'preview-badge code';
+    const ext = filePath.split('.').pop() || '';
+    if (['md','markdown'].includes(ext)) {
+      showPreview('md');
+      $('previewMd').innerHTML = renderMd(data.content || '');
+    } else {
+      showPreview('code');
+      $('previewCode').textContent = data.content || '';
+      requestAnimationFrame(() => highlightCode());
+    }
+  } catch(e) { setStatus('Could not load file: ' + e.message); }
+}
+
 // ── Skill create/edit form ──
 let _editingSkillName = null;
 
@@ -476,6 +580,7 @@ function toggleWsDropdown(){
   const open=dd.classList.contains('open');
   if(open){closeWsDropdown();}
   else{
+    closeProfileDropdown(); // close profile dropdown if open
     loadWorkspaceList().then(data=>{
       renderWorkspaceDropdown(data.workspaces, S.session?S.session.workspace:'');
       dd.classList.add('open');
@@ -488,7 +593,7 @@ function closeWsDropdown(){
   if(dd)dd.classList.remove('open');
 }
 document.addEventListener('click',e=>{
-  if(!e.target.closest('#wsChipWrap'))closeWsDropdown();
+  if(!e.target.closest('#sidebarWsDisplay') && !e.target.closest('#wsDropdown'))closeWsDropdown();
 });
 
 async function loadWorkspacesPanel(){
@@ -561,6 +666,210 @@ async function switchToWorkspace(path,name){
   }catch(e){setStatus('Switch failed: '+e.message);}
 }
 
+// ── Profile panel + dropdown ──
+let _profilesCache = null;
+
+async function loadProfilesPanel() {
+  const panel = $('profilesPanel');
+  if (!panel) return;
+  try {
+    const data = await api('/api/profiles');
+    _profilesCache = data;
+    panel.innerHTML = '';
+    if (!data.profiles || !data.profiles.length) {
+      panel.innerHTML = '<div style="padding:16px;color:var(--muted);font-size:12px">No profiles found.</div>';
+      return;
+    }
+    for (const p of data.profiles) {
+      const card = document.createElement('div');
+      card.className = 'profile-card';
+      const meta = [];
+      if (p.model) meta.push(p.model.split('/').pop());
+      if (p.provider) meta.push(p.provider);
+      if (p.skill_count) meta.push(p.skill_count + ' skill' + (p.skill_count !== 1 ? 's' : ''));
+      if (p.has_env) meta.push('API keys configured');
+      const gwDot = p.gateway_running
+        ? '<span class="profile-opt-badge running" title="Gateway running"></span>'
+        : '<span class="profile-opt-badge stopped" title="Gateway stopped"></span>';
+      const isActive = p.name === data.active;
+      const activeBadge = isActive ? '<span style="color:var(--link);font-size:10px;font-weight:600;margin-left:6px">ACTIVE</span>' : '';
+      card.innerHTML = `
+        <div class="profile-card-header">
+          <div style="min-width:0;flex:1">
+            <div class="profile-card-name${isActive ? ' is-active' : ''}">${gwDot}${esc(p.name)}${p.is_default ? ' <span style="opacity:.5">(default)</span>' : ''}${activeBadge}</div>
+            ${meta.length ? `<div class="profile-card-meta">${esc(meta.join(' \u00b7 '))}</div>` : '<div class="profile-card-meta">No configuration</div>'}
+          </div>
+          <div class="profile-card-actions">
+            ${!isActive ? `<button class="ws-action-btn" onclick="switchToProfile('${esc(p.name)}')" title="Switch to this profile">Use</button>` : ''}
+            ${!p.is_default ? `<button class="ws-action-btn danger" onclick="deleteProfile('${esc(p.name)}')" title="Delete this profile">&#10005;</button>` : ''}
+          </div>
+        </div>`;
+      panel.appendChild(card);
+    }
+  } catch (e) {
+    panel.innerHTML = `<div style="color:var(--accent);font-size:12px;padding:12px">Error: ${esc(e.message)}</div>`;
+  }
+}
+
+function renderProfileDropdown(data) {
+  const dd = $('profileDropdown');
+  if (!dd) return;
+  dd.innerHTML = '';
+  const profiles = data.profiles || [];
+  const active = data.active || 'default';
+  for (const p of profiles) {
+    const opt = document.createElement('div');
+    opt.className = 'profile-opt' + (p.name === active ? ' active' : '');
+    const meta = [];
+    if (p.model) meta.push(p.model.split('/').pop());
+    if (p.skill_count) meta.push(p.skill_count + ' skills');
+    const gwDot = `<span class="profile-opt-badge ${p.gateway_running ? 'running' : 'stopped'}"></span>`;
+    const checkmark = p.name === active ? ' <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="var(--link)" stroke-width="3" style="vertical-align:-1px"><polyline points="20 6 9 17 4 12"/></svg>' : '';
+    opt.innerHTML = `<div class="profile-opt-name">${gwDot}${esc(p.name)}${p.is_default ? ' <span style="opacity:.5;font-weight:400">(default)</span>' : ''}${checkmark}</div>` +
+      (meta.length ? `<div class="profile-opt-meta">${esc(meta.join(' \u00b7 '))}</div>` : '');
+    opt.onclick = async () => {
+      closeProfileDropdown();
+      if (p.name === active) return;
+      await switchToProfile(p.name);
+    };
+    dd.appendChild(opt);
+  }
+  // Divider + Manage link
+  const div = document.createElement('div'); div.className = 'ws-divider'; dd.appendChild(div);
+  const mgmt = document.createElement('div'); mgmt.className = 'profile-opt ws-manage';
+  mgmt.innerHTML = '&#9881; Manage profiles';
+  mgmt.onclick = () => { closeProfileDropdown(); switchPanel('profiles'); };
+  dd.appendChild(mgmt);
+}
+
+function toggleProfileDropdown() {
+  const dd = $('profileDropdown');
+  if (!dd) return;
+  if (dd.classList.contains('open')) { closeProfileDropdown(); return; }
+  closeWsDropdown(); // close workspace dropdown if open
+  api('/api/profiles').then(data => {
+    renderProfileDropdown(data);
+    dd.classList.add('open');
+  }).catch(e => { showToast('Failed to load profiles'); });
+}
+
+function closeProfileDropdown() {
+  const dd = $('profileDropdown');
+  if (dd) dd.classList.remove('open');
+}
+document.addEventListener('click', e => {
+  if (!e.target.closest('#profileChipWrap')) closeProfileDropdown();
+});
+
+async function switchToProfile(name) {
+  if (S.busy) { showToast('Cannot switch profiles while agent is running'); return; }
+
+  // Determine whether the current session has any messages.
+  // A session with messages is "in progress" and belongs to the current profile —
+  // we must not retag it.  We'll start a fresh session for the new profile instead.
+  const sessionInProgress = S.session && S.messages && S.messages.length > 0;
+
+  try {
+    const data = await api('/api/profile/switch', { method: 'POST', body: JSON.stringify({ name }) });
+    S.activeProfile = data.active || name;
+
+    // ── Model ──────────────────────────────────────────────────────────────
+    localStorage.removeItem('hermes-webui-model');
+    _skillsData = null;
+    await populateModelDropdown();
+    if (data.default_model) {
+      const sel = $('modelSelect');
+      const resolved = _applyModelToDropdown(data.default_model, sel);
+      const modelToUse = resolved || data.default_model;
+      S._pendingProfileModel = modelToUse;
+      // Only patch the in-memory session model if we're NOT about to replace the session
+      if (S.session && !sessionInProgress) {
+        S.session.model = modelToUse;
+      }
+    }
+
+    // ── Workspace ──────────────────────────────────────────────────────────
+    _workspaceList = null;
+    await loadWorkspaceList();
+    if (data.default_workspace) {
+      // Always store the profile default for new sessions
+      S._profileDefaultWorkspace = data.default_workspace;
+
+      if (S.session && !sessionInProgress) {
+        // Empty session (no messages yet) — safe to update it in place
+        try {
+          await api('/api/session/update', { method: 'POST', body: JSON.stringify({
+            session_id: S.session.session_id,
+            workspace: data.default_workspace,
+            model: S.session.model,
+          })});
+          S.session.workspace = data.default_workspace;
+        } catch (_) {}
+      }
+    }
+
+    // ── Session ────────────────────────────────────────────────────────────
+    _showAllProfiles = false;
+
+    if (sessionInProgress) {
+      // The current session has messages and belongs to the previous profile.
+      // Start a new session for the new profile so nothing gets cross-tagged.
+      await newSession(false);
+      await renderSessionList();
+      showToast('Switched to profile: ' + name + ' — new conversation started');
+    } else {
+      // No messages yet — just refresh the list and topbar in place
+      await renderSessionList();
+      syncTopbar();
+      showToast('Switched to profile: ' + name);
+    }
+
+    // ── Sidebar panels ─────────────────────────────────────────────────────
+    if (_currentPanel === 'skills') await loadSkills();
+    if (_currentPanel === 'memory') await loadMemory();
+    if (_currentPanel === 'tasks') await loadCrons();
+    if (_currentPanel === 'profiles') await loadProfilesPanel();
+    if (_currentPanel === 'workspaces') await loadWorkspacesPanel();
+
+  } catch (e) { showToast('Switch failed: ' + e.message); }
+}
+
+function toggleProfileForm() {
+  const form = $('profileCreateForm');
+  if (!form) return;
+  form.style.display = form.style.display === 'none' ? '' : 'none';
+  if (form.style.display !== 'none') {
+    $('profileFormName').value = '';
+    $('profileFormClone').checked = false;
+    const errEl = $('profileFormError');
+    if (errEl) errEl.style.display = 'none';
+    $('profileFormName').focus();
+  }
+}
+
+async function submitProfileCreate() {
+  const name = ($('profileFormName').value || '').trim().toLowerCase();
+  const cloneConfig = $('profileFormClone').checked;
+  const errEl = $('profileFormError');
+  if (!name) { errEl.textContent = 'Name is required'; errEl.style.display = ''; return; }
+  if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(name)) { errEl.textContent = 'Lowercase letters, numbers, hyphens, underscores only'; errEl.style.display = ''; return; }
+  try {
+    await api('/api/profile/create', { method: 'POST', body: JSON.stringify({ name, clone_config: cloneConfig }) });
+    toggleProfileForm();
+    await loadProfilesPanel();
+    showToast('Profile created: ' + name);
+  } catch (e) { errEl.textContent = e.message || 'Create failed'; errEl.style.display = ''; }
+}
+
+async function deleteProfile(name) {
+  if (!confirm(`Delete profile "${name}"? This removes all config, skills, memory, and sessions for this profile.`)) return;
+  try {
+    await api('/api/profile/delete', { method: 'POST', body: JSON.stringify({ name }) });
+    await loadProfilesPanel();
+    showToast('Profile deleted: ' + name);
+  } catch (e) { showToast('Delete failed: ' + e.message); }
+}
+
 // ── Memory panel ──
 async function loadMemory(force) {
   const panel = $('memoryPanel');
@@ -599,17 +908,70 @@ document.addEventListener('drop',e=>{e.preventDefault();dragCounter=0;wrap.class
 
 // ── Settings panel ───────────────────────────────────────────────────────────
 
+let _settingsDirty = false;
+let _settingsThemeOnOpen = null; // track theme at open time for discard revert
+
 function toggleSettings(){
   const overlay=$('settingsOverlay');
   if(!overlay) return;
   if(overlay.style.display==='none'){
+    _settingsDirty = false;
+    _settingsThemeOnOpen = document.documentElement.dataset.theme || 'dark';
     overlay.style.display='';
     loadSettingsPanel();
   } else {
-    overlay.style.display='none';
+    _closeSettingsPanel();
   }
 }
 
+// Close with unsaved-changes check. If dirty, show a confirm dialog.
+function _closeSettingsPanel(){
+  if(!_settingsDirty){
+    // Nothing changed -- revert any live preview and close
+    _revertSettingsPreview();
+    $('settingsOverlay').style.display='none';
+    return;
+  }
+  // Dirty -- show inline confirm bar
+  _showSettingsUnsavedBar();
+}
+
+// Revert live DOM/localStorage to what they were when the panel opened
+function _revertSettingsPreview(){
+  if(_settingsThemeOnOpen){
+    document.documentElement.dataset.theme = _settingsThemeOnOpen;
+    localStorage.setItem('hermes-theme', _settingsThemeOnOpen);
+  }
+}
+
+// Show the "Unsaved changes" bar inside the settings panel
+function _showSettingsUnsavedBar(){
+  let bar = $('settingsUnsavedBar');
+  if(bar){ bar.style.display=''; return; }
+  // Create it
+  bar = document.createElement('div');
+  bar.id = 'settingsUnsavedBar';
+  bar.style.cssText = 'display:flex;align-items:center;justify-content:space-between;gap:8px;background:rgba(233,69,96,.12);border:1px solid rgba(233,69,96,.3);border-radius:8px;padding:10px 14px;margin:0 0 12px;font-size:13px;';
+  bar.innerHTML = '<span style="color:var(--text)">You have unsaved changes.</span>'
+    + '<span style="display:flex;gap:8px">'
+    + '<button onclick="_discardSettings()" style="padding:5px 12px;border-radius:6px;border:1px solid var(--border2);background:rgba(255,255,255,.06);color:var(--muted);cursor:pointer;font-size:12px;font-weight:600">Discard</button>'
+    + '<button onclick="saveSettings(true)" style="padding:5px 12px;border-radius:6px;border:none;background:var(--accent);color:#fff;cursor:pointer;font-size:12px;font-weight:600">Save</button>'
+    + '</span>';
+  const body = document.querySelector('.settings-body') || document.querySelector('.settings-panel');
+  if(body) body.prepend(bar);
+}
+
+function _discardSettings(){
+  _revertSettingsPreview();
+  _settingsDirty = false;
+  $('settingsOverlay').style.display = 'none';
+}
+
+// Mark settings as dirty whenever anything changes
+function _markSettingsDirty(){
+  _settingsDirty = true;
+}
+
 async function loadSettingsPanel(){
   try{
     const settings=await api('/api/settings');
@@ -631,45 +993,119 @@ async function loadSettingsPanel(){
         }
       }catch(e){}
       modelSel.value=settings.default_model||'';
+      modelSel.addEventListener('change',_markSettingsDirty,{once:false});
     }
-    // Populate workspace dropdown from /api/workspaces
-    const wsSel=$('settingsWorkspace');
-    if(wsSel){
-      wsSel.innerHTML='';
-      try{
-        const wsData=await api('/api/workspaces');
-        for(const w of (wsData.workspaces||[])){
-          const opt=document.createElement('option');
-          opt.value=w.path;opt.textContent=w.name||w.path;
-          wsSel.appendChild(opt);
-        }
-      }catch(e){}
-      wsSel.value=settings.default_workspace||'';
-    }
+    // Send key preference
+    const sendKeySel=$('settingsSendKey');
+    if(sendKeySel){sendKeySel.value=settings.send_key||'enter';sendKeySel.addEventListener('change',_markSettingsDirty,{once:false});}
+    // Theme preference
+    const themeSel=$('settingsTheme');
+    if(themeSel){themeSel.value=settings.theme||'dark';themeSel.addEventListener('change',_markSettingsDirty,{once:false});}
+    const showUsageCb=$('settingsShowTokenUsage');
+    if(showUsageCb){showUsageCb.checked=!!settings.show_token_usage;showUsageCb.addEventListener('change',_markSettingsDirty,{once:false});}
+    const showCliCb=$('settingsShowCliSessions');
+    if(showCliCb){showCliCb.checked=!!settings.show_cli_sessions;showCliCb.addEventListener('change',_markSettingsDirty,{once:false});}
+    const syncCb=$('settingsSyncInsights');
+    if(syncCb){syncCb.checked=!!settings.sync_to_insights;syncCb.addEventListener('change',_markSettingsDirty,{once:false});}
+    const updateCb=$('settingsCheckUpdates');
+    if(updateCb){updateCb.checked=settings.check_for_updates!==false;updateCb.addEventListener('change',_markSettingsDirty,{once:false});}
+    // Bot name
+    const botNameField=$('settingsBotName');
+    if(botNameField){botNameField.value=settings.bot_name||'Hermes';botNameField.addEventListener('input',_markSettingsDirty,{once:false});}
+    // Password field: always blank (we don't send hash back)
+    const pwField=$('settingsPassword');
+    if(pwField){pwField.value='';pwField.addEventListener('input',_markSettingsDirty,{once:false});}
+    // Show auth buttons only when auth is active
+    try{
+      const authStatus=await api('/api/auth/status');
+      const active=authStatus.auth_enabled;
+      const signOutBtn=$('btnSignOut');
+      if(signOutBtn) signOutBtn.style.display=active?'':'none';
+      const disableBtn=$('btnDisableAuth');
+      if(disableBtn) disableBtn.style.display=active?'':'none';
+    }catch(e){}
   }catch(e){
     showToast('Failed to load settings: '+e.message);
   }
 }
 
-async function saveSettings(){
+async function saveSettings(andClose){
   const model=($('settingsModel')||{}).value;
-  const workspace=($('settingsWorkspace')||{}).value;
+  const sendKey=($('settingsSendKey')||{}).value;
+  const showTokenUsage=!!($('settingsShowTokenUsage')||{}).checked;
+  const showCliSessions=!!($('settingsShowCliSessions')||{}).checked;
+  const pw=($('settingsPassword')||{}).value;
+  const theme=($('settingsTheme')||{}).value||'dark';
   const body={};
   if(model) body.default_model=model;
-  if(workspace) body.default_workspace=workspace;
+
+  if(sendKey) body.send_key=sendKey;
+  body.theme=theme;
+  body.show_token_usage=showTokenUsage;
+  body.show_cli_sessions=showCliSessions;
+  body.sync_to_insights=!!($('settingsSyncInsights')||{}).checked;
+  body.check_for_updates=!!($('settingsCheckUpdates')||{}).checked;
+  const botName=(($('settingsBotName')||{}).value||'').trim();
+  body.bot_name=botName||'Hermes';
+  // Password: only act if the field has content; blank = leave auth unchanged
+  if(pw && pw.trim()){
+    try{
+      await api('/api/settings',{method:'POST',body:JSON.stringify({...body,_set_password:pw.trim()})});
+      window._sendKey=sendKey||'enter';
+      window._showTokenUsage=showTokenUsage;
+      showToast('Settings saved (password set — login now required)');
+      _settingsDirty=false; _settingsThemeOnOpen=theme;
+      const bar=$('settingsUnsavedBar'); if(bar) bar.style.display='none';
+      $('settingsOverlay').style.display='none';
+      return;
+    }catch(e){showToast('Save failed: '+e.message);return;}
+  }
   try{
     await api('/api/settings',{method:'POST',body:JSON.stringify(body)});
+    window._sendKey=sendKey||'enter';
+    window._showTokenUsage=showTokenUsage;
+    window._showCliSessions=showCliSessions;
+    window._botName=body.bot_name;
+    if(typeof applyBotName==='function') applyBotName();
+    _settingsDirty=false; _settingsThemeOnOpen=theme;
+    const bar=$('settingsUnsavedBar'); if(bar) bar.style.display='none';
+    renderMessages();
+    if(typeof renderSessionList==='function') renderSessionList();
     showToast('Settings saved');
-    toggleSettings();
+    $('settingsOverlay').style.display='none';
   }catch(e){
     showToast('Save failed: '+e.message);
   }
 }
 
-// Close settings on overlay click (not panel click)
+async function signOut(){
+  try{
+    await api('/api/auth/logout',{method:'POST',body:'{}'});
+    window.location.href='/login';
+  }catch(e){
+    showToast('Sign out failed: '+e.message);
+  }
+}
+
+async function disableAuth(){
+  if(!confirm('Disable password protection? Anyone will be able to access this instance.')) return;
+  try{
+    await api('/api/settings',{method:'POST',body:JSON.stringify({_clear_password:true})});
+    showToast('Auth disabled — password protection removed');
+    // Hide both auth buttons since auth is now off
+    const disableBtn=$('btnDisableAuth');
+    if(disableBtn) disableBtn.style.display='none';
+    const signOutBtn=$('btnSignOut');
+    if(signOutBtn) signOutBtn.style.display='none';
+  }catch(e){
+    showToast('Failed to disable auth: '+e.message);
+  }
+}
+
+// Close settings on overlay click (not panel click) -- with unsaved-changes check
 document.addEventListener('click',e=>{
   const overlay=$('settingsOverlay');
-  if(overlay&&e.target===overlay) toggleSettings();
+  if(overlay&&e.target===overlay) _closeSettingsPanel();
 });
 
 // ── Cron completion alerts ────────────────────────────────────────────────────

static/sessions.js

@@ -1,8 +1,22 @@
+// ── Session action icons (SVG, monochrome, inherit currentColor) ──
+const ICONS={
+  pin:'<svg width="14" height="14" viewBox="0 0 16 16" fill="currentColor" stroke="none"><polygon points="8,1.5 9.8,5.8 14.5,6.2 11,9.4 12,14 8,11.5 4,14 5,9.4 1.5,6.2 6.2,5.8"/></svg>',
+  unpin:'<svg width="14" height="14" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.3"><polygon points="8,2 9.8,6.2 14.2,6.2 10.7,9.2 12,13.8 8,11 4,13.8 5.3,9.2 1.8,6.2 6.2,6.2"/></svg>',
+  folder:'<svg width="14" height="14" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.3"><path d="M2 4.5h4l1.5 1.5H14v7H2z"/></svg>',
+  archive:'<svg width="14" height="14" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.3"><rect x="1.5" y="2" width="13" height="3" rx="1"/><path d="M2.5 5v8h11V5"/><line x1="6" y1="8.5" x2="10" y2="8.5"/></svg>',
+  unarchive:'<svg width="14" height="14" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.3"><rect x="1.5" y="2" width="13" height="3" rx="1"/><path d="M2.5 5v8h11V5"/><polyline points="6.5,7 8,5.5 9.5,7"/></svg>',
+  dup:'<svg width="14" height="14" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.3"><rect x="4.5" y="4.5" width="8.5" height="8.5" rx="1.5"/><path d="M3 11.5V3h8.5"/></svg>',
+  trash:'<svg width="14" height="14" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.3"><path d="M3.5 4.5h9M6.5 4.5V3h3v1.5M4.5 4.5v8.5h7v-8.5"/><line x1="7" y1="7" x2="7" y2="11"/><line x1="9" y1="7" x2="9" y2="11"/></svg>',
+};
+
 async function newSession(flash){
   MSG_QUEUE.length=0;updateQueueBadge();
   S.toolCalls=[];
   clearLiveToolCards();
-  const inheritWs=S.session?S.session.workspace:null;
+  // Use profile default workspace for new sessions after a profile switch (one-shot),
+  // otherwise inherit from the current session (or let server pick the default)
+  const inheritWs=S._profileDefaultWorkspace||(S.session?S.session.workspace:null);
+  S._profileDefaultWorkspace=null; // consume — only applies to the first new session after switch
   const data=await api('/api/session/new',{method:'POST',body:JSON.stringify({model:$('modelSelect').value,workspace:inheritWs})});
   S.session=data.session;S.messages=data.session.messages||[];
   if(flash)S.session._flash=true;
@@ -31,7 +45,7 @@ async function loadSession(sid){
       if(tc&&tc.name) appendLiveToolCard(tc);
     }
     syncTopbar();await loadDir('.');renderMessages();appendThinking();
-    setBusy(true);setStatus('Hermes is thinking\u2026');
+    setBusy(true);setStatus((window._botName||'Hermes')+' is thinking\u2026');
     startApprovalPolling(sid);
   }else{
     MSG_QUEUE.length=0;updateQueueBadge();  // clear queue for the viewed session
@@ -56,12 +70,19 @@ async function loadSession(sid){
 let _allSessions = [];  // cached for search filter
 let _renamingSid = null;  // session_id currently being renamed (blocks list re-renders)
 let _showArchived = false;  // toggle to show archived sessions
+let _allProjects = [];  // cached project list
+let _activeProject = null;  // project_id filter (null = show all)
+let _showAllProfiles = false;  // false = filter to active profile only
 
 async function renderSessionList(){
   try{
     if(!($('sessionSearch').value||'').trim()) _contentSearchResults = [];
-    const data=await api('/api/sessions');
-    _allSessions = data.sessions||[];
+    const [sessData, projData] = await Promise.all([
+      api('/api/sessions'),
+      api('/api/projects'),
+    ]);
+    _allSessions = sessData.sessions||[];
+    _allProjects = projData.projects||[];
     renderSessionListFromCache();  // no-ops if rename is in progress
   }catch(e){console.warn('renderSessionList',e);}
 }
@@ -94,10 +115,68 @@ function renderSessionListFromCache(){
   // Merge content matches (deduped): content matches appended after title matches
   const titleIds=new Set(titleMatches.map(s=>s.session_id));
   const allMatched=q?[...titleMatches,..._contentSearchResults.filter(s=>!titleIds.has(s.session_id))]:titleMatches;
+  // Filter by active profile (unless "All profiles" is toggled on)
+  // Server backfills profile='default' for legacy sessions, so every session has a profile.
+  // Show only sessions tagged to the active profile; 'All profiles' toggle overrides.
+  const profileFiltered=_showAllProfiles?allMatched:allMatched.filter(s=>s.is_cli_session||s.profile===S.activeProfile);
+  // Filter by active project
+  const projectFiltered=_activeProject?profileFiltered.filter(s=>s.project_id===_activeProject):profileFiltered;
   // Filter archived unless toggle is on
-  const sessions=_showArchived?allMatched:allMatched.filter(s=>!s.archived);
-  const archivedCount=allMatched.filter(s=>s.archived).length;
+  const sessions=_showArchived?projectFiltered:projectFiltered.filter(s=>!s.archived);
+  const archivedCount=projectFiltered.filter(s=>s.archived).length;
   const list=$('sessionList');list.innerHTML='';
+  // Project filter bar (only when projects exist)
+  if(_allProjects.length>0){
+    const bar=document.createElement('div');
+    bar.className='project-bar';
+    // "All" chip
+    const allChip=document.createElement('span');
+    allChip.className='project-chip'+(!_activeProject?' active':'');
+    allChip.textContent='All';
+    allChip.onclick=()=>{_activeProject=null;renderSessionListFromCache();};
+    bar.appendChild(allChip);
+    // Project chips
+    for(const p of _allProjects){
+      const chip=document.createElement('span');
+      chip.className='project-chip'+(p.project_id===_activeProject?' active':'');
+      if(p.color){
+        const dot=document.createElement('span');
+        dot.className='color-dot';
+        dot.style.background=p.color;
+        chip.appendChild(dot);
+      }
+      const nameSpan=document.createElement('span');
+      nameSpan.textContent=p.name;
+      chip.appendChild(nameSpan);
+      chip.onclick=()=>{_activeProject=p.project_id;renderSessionListFromCache();};
+      chip.ondblclick=(e)=>{e.stopPropagation();_startProjectRename(p,chip);};
+      chip.oncontextmenu=(e)=>{e.preventDefault();_confirmDeleteProject(p);};
+      bar.appendChild(chip);
+    }
+    // Create button
+    const addBtn=document.createElement('button');
+    addBtn.className='project-create-btn';
+    addBtn.textContent='+';
+    addBtn.title='New project';
+    addBtn.onclick=(e)=>{e.stopPropagation();_startProjectCreate(bar,addBtn);};
+    bar.appendChild(addBtn);
+    list.appendChild(bar);
+  }
+  // Profile filter toggle (show sessions from other profiles)
+  const otherProfileCount=allMatched.filter(s=>s.profile&&s.profile!==S.activeProfile).length;
+  if(otherProfileCount>0&&!_showAllProfiles){
+    const pfToggle=document.createElement('div');
+    pfToggle.style.cssText='font-size:10px;padding:4px 10px;color:var(--muted);cursor:pointer;text-align:center;opacity:.7;';
+    pfToggle.textContent='Show '+otherProfileCount+' from other profiles';
+    pfToggle.onclick=()=>{_showAllProfiles=true;renderSessionListFromCache();};
+    list.appendChild(pfToggle);
+  } else if(_showAllProfiles&&otherProfileCount>0){
+    const pfToggle=document.createElement('div');
+    pfToggle.style.cssText='font-size:10px;padding:4px 10px;color:var(--muted);cursor:pointer;text-align:center;opacity:.7;';
+    pfToggle.textContent='Show active profile only';
+    pfToggle.onclick=()=>{_showAllProfiles=false;renderSessionListFromCache();};
+    list.appendChild(pfToggle);
+  }
   // Show/hide archived toggle if there are archived sessions
   if(archivedCount>0){
     const toggle=document.createElement('div');
@@ -106,35 +185,69 @@ function renderSessionListFromCache(){
     toggle.onclick=()=>{_showArchived=!_showArchived;renderSessionListFromCache();};
     list.appendChild(toggle);
   }
+  // Empty state for active project filter
+  if(_activeProject&&sessions.length===0){
+    const empty=document.createElement('div');
+    empty.style.cssText='padding:20px 14px;color:var(--muted);font-size:12px;text-align:center;opacity:.7;';
+    empty.textContent='No sessions in this project yet.';
+    list.appendChild(empty);
+  }
   // Separate pinned from unpinned
   const pinned=sessions.filter(s=>s.pinned);
   const unpinned=sessions.filter(s=>!s.pinned);
   // Date grouping: Pinned / Today / Yesterday / Earlier
   const now=Date.now();
   const ONE_DAY=86400000;
-  let lastGroup='';
-  const ordered=[...pinned,...unpinned].slice(0,50);
-  if(pinned.length){
-    const hdr=document.createElement('div');
-    hdr.style.cssText='font-size:10px;font-weight:700;text-transform:uppercase;letter-spacing:.08em;color:#f5c542;padding:10px 10px 4px;opacity:.9;';
-    hdr.textContent='\u2605 Pinned';
-    list.appendChild(hdr);
+  // Collapse state persisted in localStorage
+  let _groupCollapsed={};
+  try{_groupCollapsed=JSON.parse(localStorage.getItem('hermes-date-groups-collapsed')||'{}');}catch(e){}
+  const _saveCollapsed=()=>{try{localStorage.setItem('hermes-date-groups-collapsed',JSON.stringify(_groupCollapsed));}catch(e){}};
+  // Group sessions by date
+  const groups=[];
+  let curLabel=null,curItems=[];
+  if(pinned.length) groups.push({label:'\u2605 Pinned',items:pinned,isPinned:true});
+  for(const s of unpinned){
+    const ts=(s.updated_at||s.created_at||0)*1000;
+    const label=ts>now-ONE_DAY?'Today':ts>now-2*ONE_DAY?'Yesterday':'Earlier';
+    if(label!==curLabel){
+      if(curItems.length) groups.push({label:curLabel,items:curItems});
+      curLabel=label;curItems=[s];
+    } else { curItems.push(s); }
   }
-  for(const s of ordered){
-    if(!s.pinned){
-      const ts=(s.updated_at||s.created_at||0)*1000;  // group by last activity, not creation
-      const group=ts>now-ONE_DAY?'Today':ts>now-2*ONE_DAY?'Yesterday':'Earlier';
-      if(group!==lastGroup){
-        lastGroup=group;
-        const hdr=document.createElement('div');
-        hdr.style.cssText='font-size:10px;font-weight:700;text-transform:uppercase;letter-spacing:.08em;color:var(--muted);padding:10px 10px 4px;opacity:.8;';
-        hdr.textContent=group;
-        list.appendChild(hdr);
-      }
-    }
+  if(curItems.length) groups.push({label:curLabel,items:curItems});
+  // Render groups with collapsible headers
+  for(const g of groups){
+    const wrapper=document.createElement('div');
+    wrapper.className='session-date-group';
+    const hdr=document.createElement('div');
+    hdr.className='session-date-header'+(g.isPinned?' pinned':'');
+    const caret=document.createElement('span');
+    caret.className='session-date-caret';
+    caret.textContent='\u25B8'; // right-pointing triangle
+    const label=document.createElement('span');
+    label.textContent=g.label;
+    hdr.appendChild(caret);hdr.appendChild(label);
+    const body=document.createElement('div');
+    body.className='session-date-body';
+    if(_groupCollapsed[g.label]){body.style.display='none';caret.classList.add('collapsed');}
+    hdr.onclick=()=>{
+      const isCollapsed=body.style.display==='none';
+      body.style.display=isCollapsed?'':'none';
+      caret.classList.toggle('collapsed',!isCollapsed);
+      _groupCollapsed[g.label]=!isCollapsed;
+      _saveCollapsed();
+    };
+    wrapper.appendChild(hdr);
+    for(const s of g.items){ body.appendChild(_renderOneSession(s)); }
+    wrapper.appendChild(body);
+    list.appendChild(wrapper);
+  }
+  // ── Render session items (extracted for group body use) ──
+  // Note: declared after the groups loop but available via function hoisting.
+  function _renderOneSession(s){
     const el=document.createElement('div');
     const isActive=S.session&&s.session_id===S.session.session_id;
-    el.className='session-item'+(isActive?' active':'')+(isActive&&S.session&&S.session._flash?' new-flash':'')+(s.archived?' archived':'');
+    el.className='session-item'+(isActive?' active':'')+(isActive&&S.session&&S.session._flash?' new-flash':'')+(s.archived?' archived':'')+(s.is_cli_session?' cli-session':'');
     if(isActive&&S.session&&S.session._flash)delete S.session._flash;
     const rawTitle=s.title||'Untitled';
     const tags=(rawTitle.match(/#[\w-]+/g)||[]);
@@ -190,11 +303,35 @@ function renderSessionListFromCache(){
       setTimeout(()=>{inp.focus();inp.select();},10);
     };
 
-    const pin=document.createElement('span');
-    pin.className='session-pin'+(s.pinned?' pinned':'');
-    pin.innerHTML=s.pinned?'&#9733;':'&#9734;';
-    pin.title=s.pinned?'Unpin':'Pin to top';
-    pin.onclick=async(e)=>{
+    // Pin indicator (inline, only when pinned — no space reserved otherwise)
+    if(s.pinned){
+      const pinInd=document.createElement('span');
+      pinInd.className='session-pin-indicator';
+      pinInd.innerHTML=ICONS.pin;
+      el.appendChild(pinInd);
+    }
+    // Project indicator: colored left border (active item keeps its own gold color)
+    if(s.project_id){
+      const proj=_allProjects.find(p=>p.project_id===s.project_id);
+      if(proj){
+        if(!isActive) el.style.borderLeftColor=proj.color||'var(--blue)';
+        const dot=document.createElement('span');
+        dot.className='session-project-dot';
+        dot.style.background=proj.color||'var(--blue)';
+        dot.title=proj.name;
+        title.appendChild(dot);
+      }
+    }
+    el.appendChild(title);
+    // Action buttons overlay (appears on hover with gradient fade)
+    const actions=document.createElement('div');
+    actions.className='session-actions';
+    // Pin toggle
+    const pinBtn=document.createElement('button');
+    pinBtn.className='act-pin'+(s.pinned?' pinned':'');
+    pinBtn.innerHTML=s.pinned?ICONS.pin:ICONS.unpin;
+    pinBtn.title=s.pinned?'Unpin':'Pin to top';
+    pinBtn.onclick=async(e)=>{
       e.stopPropagation();e.preventDefault();
       const newPinned=!s.pinned;
       try{
@@ -204,8 +341,15 @@ function renderSessionListFromCache(){
         renderSessionList();
       }catch(err){showToast('Pin failed: '+err.message);}
     };
+    actions.appendChild(pinBtn);
+    // Move to project
+    const move=document.createElement('button');
+    move.className='act-move';move.innerHTML=ICONS.folder;move.title='Move to project';
+    move.onclick=async(e)=>{e.stopPropagation();e.preventDefault();_showProjectPicker(s,move);};
+    actions.appendChild(move);
+    // Archive
     const archive=document.createElement('button');
-    archive.className='session-action-btn';archive.innerHTML=s.archived?'&#9993;':'&#128230;';
+    archive.className='act-archive';archive.innerHTML=s.archived?ICONS.unarchive:ICONS.archive;
     archive.title=s.archived?'Unarchive':'Archive';
     archive.onclick=async(e)=>{
       e.stopPropagation();e.preventDefault();
@@ -217,8 +361,10 @@ function renderSessionListFromCache(){
         showToast(s.archived?'Session archived':'Session restored');
       }catch(err){showToast('Archive failed: '+err.message);}
     };
+    actions.appendChild(archive);
+    // Duplicate
     const dup=document.createElement('button');
-    dup.className='session-dup';dup.innerHTML='&#10697;';dup.title='Duplicate';
+    dup.className='act-dup';dup.innerHTML=ICONS.dup;dup.title='Duplicate';
     dup.onclick=async(e)=>{
       e.stopPropagation();e.preventDefault();
       try{
@@ -230,10 +376,13 @@ function renderSessionListFromCache(){
         }
       }catch(err){showToast('Duplicate failed: '+err.message);}
     };
+    actions.appendChild(dup);
+    // Trash
     const trash=document.createElement('button');
-    trash.className='session-trash';trash.innerHTML='&#128465;';trash.title='Delete';
+    trash.className='act-trash';trash.innerHTML=ICONS.trash;trash.title='Delete';
     trash.onclick=async(e)=>{e.stopPropagation();e.preventDefault();await deleteSession(s.session_id);};
-    el.appendChild(pin);el.appendChild(title);el.appendChild(archive);el.appendChild(dup);el.appendChild(trash);
+    actions.appendChild(trash);
+    el.appendChild(actions);
 
     // Use a click timer to distinguish single-click (navigate) from double-click (rename).
     // This prevents loadSession from firing on the first click of a double-click,
@@ -241,12 +390,19 @@ function renderSessionListFromCache(){
     let _clickTimer=null;
     el.onclick=async(e)=>{
       if(_renamingSid) return; // ignore while any rename is active
-      if([trash,dup,archive].some(b=>e.target===b||b.contains(e.target))) return;
+      if(actions.contains(e.target)) return;
       clearTimeout(_clickTimer);
       _clickTimer=setTimeout(async()=>{
         _clickTimer=null;
         if(_renamingSid) return;
+        // For CLI sessions, import into WebUI store first (idempotent)
+        if(s.is_cli_session){
+          try{
+            await api('/api/session/import_cli',{method:'POST',body:JSON.stringify({session_id:s.session_id})});
+          }catch(e){ /* import failed -- fall through to read-only view */ }
+        }
         await loadSession(s.session_id);renderSessionListFromCache();
+        if(typeof closeMobileSidebar==='function')closeMobileSidebar();
       }, 220);
     };
     el.ondblclick=async(e)=>{
@@ -256,7 +412,7 @@ function renderSessionListFromCache(){
       _clickTimer=null;
       startRename();
     };
-    list.appendChild(el);
+    return el;
   }
 }
 
@@ -273,7 +429,7 @@ async function deleteSession(sid){
     if(remaining.sessions&&remaining.sessions.length){
       await loadSession(remaining.sessions[0].session_id);
     }else{
-      $('topbarTitle').textContent='Hermes';
+      $('topbarTitle').textContent=window._botName||'Hermes';
       $('topbarMeta').textContent='Start a new conversation';
       $('msgInner').innerHTML='';
       $('emptyState').style.display='';
@@ -284,4 +440,150 @@ async function deleteSession(sid){
   await renderSessionList();
 }
 
+// ── Project helpers ─────────────────────────────────────────────────────
+
+const PROJECT_COLORS=['#7cb9ff','#f5c542','#e94560','#50c878','#c084fc','#fb923c','#67e8f9','#f472b6'];
+
+function _showProjectPicker(session, anchorEl){
+  // Close any existing picker
+  document.querySelectorAll('.project-picker').forEach(p=>p.remove());
+  const picker=document.createElement('div');
+  picker.className='project-picker';
+  // "No project" option
+  const none=document.createElement('div');
+  none.className='project-picker-item'+(!session.project_id?' active':'');
+  none.textContent='No project';
+  none.onclick=async()=>{
+    picker.remove();
+    document.removeEventListener('click',close);
+    await api('/api/session/move',{method:'POST',body:JSON.stringify({session_id:session.session_id,project_id:null})});
+    session.project_id=null;
+    renderSessionListFromCache();
+    showToast('Removed from project');
+  };
+  picker.appendChild(none);
+  // Project options
+  for(const p of _allProjects){
+    const item=document.createElement('div');
+    item.className='project-picker-item'+(session.project_id===p.project_id?' active':'');
+    if(p.color){
+      const dot=document.createElement('span');
+      dot.className='color-dot';
+      dot.style.cssText='width:6px;height:6px;border-radius:50%;background:'+p.color+';flex-shrink:0;';
+      item.appendChild(dot);
+    }
+    const name=document.createElement('span');
+    name.textContent=p.name;
+    item.appendChild(name);
+    item.onclick=async()=>{
+      picker.remove();
+      document.removeEventListener('click',close);
+      await api('/api/session/move',{method:'POST',body:JSON.stringify({session_id:session.session_id,project_id:p.project_id})});
+      session.project_id=p.project_id;
+      renderSessionListFromCache();
+      showToast('Moved to '+p.name);
+    };
+    picker.appendChild(item);
+  }
+  // "+ New project" shortcut at the bottom
+  const createItem=document.createElement('div');
+  createItem.className='project-picker-item project-picker-create';
+  createItem.textContent='+ New project';
+  createItem.onclick=async()=>{
+    picker.remove();
+    document.removeEventListener('click',close);
+    // Prompt for name inline
+    const name=prompt('Project name:');
+    if(!name||!name.trim()) return;
+    const color=PROJECT_COLORS[_allProjects.length%PROJECT_COLORS.length];
+    const res=await api('/api/projects/create',{method:'POST',body:JSON.stringify({name:name.trim(),color})});
+    if(res.project){
+      _allProjects.push(res.project);
+      // Now move session into it
+      await api('/api/session/move',{method:'POST',body:JSON.stringify({session_id:session.session_id,project_id:res.project.project_id})});
+      session.project_id=res.project.project_id;
+      await renderSessionList();
+      showToast('Created "'+res.project.name+'" and moved session');
+    }
+  };
+  picker.appendChild(createItem);
+  // Append to body and position using getBoundingClientRect so it isn't clipped
+  // by overflow:hidden on .session-item ancestors
+  document.body.appendChild(picker);
+  const rect=anchorEl.getBoundingClientRect();
+  picker.style.position='fixed';
+  picker.style.zIndex='999';
+  // Prefer opening below; flip above if too close to bottom of viewport
+  const spaceBelow=window.innerHeight-rect.bottom;
+  if(spaceBelow<160&&rect.top>160){
+    picker.style.bottom=(window.innerHeight-rect.top+4)+'px';
+    picker.style.top='auto';
+  }else{
+    picker.style.top=(rect.bottom+4)+'px';
+    picker.style.bottom='auto';
+  }
+  // Align right edge of picker with right edge of button; keep within viewport
+  const pickerW=Math.min(220,Math.max(160,picker.scrollWidth||160));
+  let left=rect.right-pickerW;
+  if(left<8) left=8;
+  picker.style.left=left+'px';
+  // Close on outside click
+  const close=(e)=>{if(!picker.contains(e.target)&&e.target!==anchorEl){picker.remove();document.removeEventListener('click',close);}};
+  setTimeout(()=>document.addEventListener('click',close),0);
+}
+
+function _startProjectCreate(bar, addBtn){
+  const inp=document.createElement('input');
+  inp.className='project-create-input';
+  inp.placeholder='Project name';
+  const finish=async(save)=>{
+    if(save&&inp.value.trim()){
+      const color=PROJECT_COLORS[_allProjects.length%PROJECT_COLORS.length];
+      await api('/api/projects/create',{method:'POST',body:JSON.stringify({name:inp.value.trim(),color})});
+      await renderSessionList();
+      showToast('Project created');
+    }else{
+      inp.replaceWith(addBtn);
+    }
+  };
+  inp.onkeydown=(e)=>{
+    if(e.key==='Enter'){e.preventDefault();finish(true);}
+    if(e.key==='Escape'){e.preventDefault();finish(false);}
+  };
+  inp.onblur=()=>finish(false);
+  addBtn.replaceWith(inp);
+  setTimeout(()=>inp.focus(),10);
+}
+
+function _startProjectRename(proj, chip){
+  const inp=document.createElement('input');
+  inp.className='project-create-input';
+  inp.value=proj.name;
+  const finish=async(save)=>{
+    if(save&&inp.value.trim()&&inp.value.trim()!==proj.name){
+      await api('/api/projects/rename',{method:'POST',body:JSON.stringify({project_id:proj.project_id,name:inp.value.trim()})});
+      await renderSessionList();
+      showToast('Project renamed');
+    }else{
+      renderSessionListFromCache();
+    }
+  };
+  inp.onkeydown=(e)=>{
+    if(e.key==='Enter'){e.preventDefault();finish(true);}
+    if(e.key==='Escape'){e.preventDefault();finish(false);}
+  };
+  inp.onblur=()=>finish(false);
+  inp.onclick=(e)=>e.stopPropagation();
+  chip.replaceWith(inp);
+  setTimeout(()=>{inp.focus();inp.select();},10);
+}
+
+async function _confirmDeleteProject(proj){
+  if(!confirm('Delete project "'+proj.name+'"? Sessions will be unassigned but not deleted.')){return;}
+  await api('/api/projects/delete',{method:'POST',body:JSON.stringify({project_id:proj.project_id})});
+  if(_activeProject===proj.project_id) _activeProject=null;
+  await renderSessionList();
+  showToast('Project deleted');
+}
+
 

static/style.css

@@ -2,11 +2,107 @@
   :root {
     --bg:#1a1a2e;--sidebar:#16213e;--border:rgba(255,255,255,0.08);--border2:rgba(255,255,255,0.14);
     --text:#e8e8f0;--muted:#8888aa;--accent:#e94560;--blue:#7cb9ff;--gold:#c9a84c;--code-bg:#0d1117;
+    --surface:#1a2535;--topbar-bg:rgba(22,33,62,.98);--main-bg:rgba(26,26,46,0.5);
+    --focus-ring:rgba(124,185,255,.35);--focus-glow:rgba(124,185,255,.08);
+    --input-bg:rgba(255,255,255,.04);--hover-bg:rgba(255,255,255,.06);
+    --strong:#fff;--em:#c9c9e8;--code-text:#f0c27f;--code-inline-bg:rgba(0,0,0,.35);--pre-text:#e2e8f0;
     font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",system-ui,sans-serif;font-size:14px;line-height:1.6;
   }
-  body{background:var(--bg);color:var(--text);height:100vh;overflow:hidden;display:flex;}
-  .layout{display:flex;width:100%;height:100vh;}
-  .sidebar{width:300px;background:var(--sidebar);border-right:1px solid var(--border);display:flex;flex-direction:column;overflow:hidden;flex-shrink:0;}
+  /* ── Slate theme ── */
+  :root[data-theme="slate"]{
+    --bg:#2b2d30;--sidebar:#25272b;--border:rgba(255,255,255,0.09);--border2:rgba(255,255,255,0.16);
+    --text:#d4d4d8;--muted:#8a8a9a;--accent:#e06c75;--blue:#82aaff;--gold:#d4a85a;--code-bg:#1e2023;
+    --surface:#2f3134;--topbar-bg:rgba(37,39,43,.98);--main-bg:rgba(43,45,48,0.5);
+    --focus-ring:rgba(130,170,255,.35);--focus-glow:rgba(130,170,255,.08);
+    --strong:#f0f0f3;--em:#b0b0c0;--code-text:#dca06a;--code-inline-bg:rgba(0,0,0,.3);--pre-text:#d0d0d6;
+  }
+  /* ── Light theme ── */
+  :root[data-theme="light"]{
+    --bg:#f0ede8;--sidebar:#e4e0d8;--border:rgba(0,0,0,0.09);--border2:rgba(0,0,0,0.15);
+    --text:#2c2825;--muted:#7a746a;--accent:#b5451b;--blue:#2d6fa3;--gold:#8a6520;--code-bg:#ddd8d0;
+    --surface:#e0dcd4;--topbar-bg:rgba(228,224,216,.98);--main-bg:rgba(240,237,232,0.5);
+    --focus-ring:rgba(45,111,163,.35);--focus-glow:rgba(45,111,163,.1);
+    --input-bg:rgba(0,0,0,.03);--hover-bg:rgba(0,0,0,.05);
+    --strong:#1a1715;--em:#5a544a;--code-text:#8b4513;--code-inline-bg:rgba(0,0,0,.06);--pre-text:#2c2825;
+  }
+  :root[data-theme="light"] ::-webkit-scrollbar-thumb{background:rgba(0,0,0,.15);}
+  :root[data-theme="light"] ::-webkit-scrollbar-thumb:hover{background:rgba(0,0,0,.3);}
+  :root[data-theme="light"] ::selection{background:rgba(45,111,163,.2);}
+  :root[data-theme="light"] *{scrollbar-color:rgba(0,0,0,.15) transparent;}
+  :root[data-theme="light"] .settings-overlay{background:rgba(0,0,0,.3);}
+  /* ── Light theme: sidebar, roles, chips, active states ── */
+  :root[data-theme="light"] .session-item{color:#5a544a;}
+  :root[data-theme="light"] .session-item:hover{background:rgba(0,0,0,.06);color:#2c2825;}
+  :root[data-theme="light"] .session-item.active{background:rgba(45,111,163,.1);color:#1a5a8a;border-left-color:#2d6fa3;}
+  :root[data-theme="light"] .session-item.active .session-actions{background:linear-gradient(to right,transparent,rgba(228,224,216,.95) 12px);}
+  :root[data-theme="light"] .session-pin-indicator{color:#996b15;}
+  :root[data-theme="light"] .session-date-header.pinned{color:#996b15;}
+  :root[data-theme="light"] .session-actions .act-pin.pinned{color:#996b15;}
+  :root[data-theme="light"] .msg-role.user{color:#2d6fa3;}
+  :root[data-theme="light"] .msg-role.assistant{color:#8a6520;}
+  :root[data-theme="light"] .role-icon.user{background:rgba(45,111,163,.12);color:#2d6fa3;border-color:rgba(45,111,163,.25);}
+  :root[data-theme="light"] .role-icon.assistant{background:rgba(138,101,32,.12);color:#8a6520;border-color:rgba(138,101,32,.25);}
+  :root[data-theme="light"] .project-chip{border-color:rgba(0,0,0,.12);background:rgba(0,0,0,.04);}
+  :root[data-theme="light"] .project-chip:hover{background:rgba(0,0,0,.08);color:#2c2825;}
+  :root[data-theme="light"] .project-chip.active{background:rgba(45,111,163,.1);color:#1a5a8a;border-color:rgba(45,111,163,.3);}
+  :root[data-theme="light"] .chip{border-color:rgba(0,0,0,.1);background:rgba(0,0,0,.04);}
+  :root[data-theme="light"] .chip.model{color:#2d6fa3;border-color:rgba(45,111,163,.3);background:rgba(45,111,163,.08);}
+  :root[data-theme="light"] .new-chat-btn{border-color:rgba(45,111,163,.25);color:#2d6fa3;}
+  :root[data-theme="light"] .new-chat-btn:hover{background:rgba(45,111,163,.08);}
+  :root[data-theme="light"] .session-search input{border-color:rgba(0,0,0,.1);background:rgba(0,0,0,.03);}
+  :root[data-theme="light"] .session-search input:focus{border-color:rgba(45,111,163,.4);background:rgba(0,0,0,.02);}
+  :root[data-theme="light"] .cron-item{border-color:rgba(0,0,0,.08);background:rgba(0,0,0,.02);}
+  :root[data-theme="light"] .sm-btn{border-color:rgba(0,0,0,.1);}
+  :root[data-theme="light"] .sm-btn:hover{background:rgba(0,0,0,.06);border-color:rgba(0,0,0,.15);}
+  :root[data-theme="light"] select{border-color:rgba(0,0,0,.12);}
+  :root[data-theme="light"] .composer-box{border-color:rgba(0,0,0,.12);}
+  :root[data-theme="light"] .composer-box:focus-within{border-color:rgba(45,111,163,.5);box-shadow:0 0 0 3px rgba(45,111,163,.08);}
+  :root[data-theme="light"] .suggestion{border-color:rgba(0,0,0,.08);}
+  :root[data-theme="light"] .suggestion:hover{background:rgba(45,111,163,.06);border-color:rgba(45,111,163,.2);}
+  :root[data-theme="light"] .tool-card{border-color:rgba(0,0,0,.08);}
+  :root[data-theme="light"] .tool-card:hover{border-color:rgba(0,0,0,.15);}
+  :root[data-theme="light"] .icon-btn:hover{background:rgba(0,0,0,.06);}
+  :root[data-theme="light"] .panel-icon-btn:hover{background:rgba(0,0,0,.06);}
+  :root[data-theme="light"] .file-item:hover{background:rgba(0,0,0,.04);}
+  :root[data-theme="light"] .preview-md th{background:rgba(0,0,0,.04);}
+  :root[data-theme="light"] .preview-md td{border-color:rgba(0,0,0,.08);}
+  :root[data-theme="light"] .preview-badge.code{background:rgba(0,0,0,.05);}
+  :root[data-theme="light"] .ctx-bar-wrap{background:rgba(0,0,0,.08);}
+  :root[data-theme="light"] .ws-opt:hover{background:rgba(0,0,0,.05);}
+  :root[data-theme="light"] .profile-opt:hover{background:rgba(0,0,0,.05);}
+  :root[data-theme="light"] .profile-opt.active{background:rgba(45,111,163,.06);}
+  :root[data-theme="light"] .profile-chip{color:#7a5a90!important;}
+  :root[data-theme="light"] .nav-tab:hover::after{background:var(--surface);border-color:rgba(45,111,163,.25);color:#2d6fa3;}
+  :root[data-theme="light"] .cron-status.disabled{background:rgba(0,0,0,.05);}
+  :root[data-theme="light"] .cron-btn{background:rgba(0,0,0,.04);}
+  :root[data-theme="light"] .cron-btn:hover{background:rgba(0,0,0,.08);}
+  /* ── Solarized Dark theme ── */
+  :root[data-theme="solarized"]{
+    --bg:#002b36;--sidebar:#073642;--border:rgba(255,255,255,0.08);--border2:rgba(255,255,255,0.13);
+    --text:#839496;--muted:#657b83;--accent:#dc322f;--blue:#268bd2;--gold:#b58900;--code-bg:#073642;
+    --surface:#0a3c48;--topbar-bg:rgba(7,54,66,.98);--main-bg:rgba(0,43,54,0.5);
+    --focus-ring:rgba(38,139,210,.35);--focus-glow:rgba(38,139,210,.08);
+    --strong:#fdf6e3;--em:#93a1a1;--code-text:#cb4b16;--code-inline-bg:rgba(0,0,0,.25);--pre-text:#93a1a1;
+  }
+  /* ── Monokai theme ── */
+  :root[data-theme="monokai"]{
+    --bg:#272822;--sidebar:#1e1f1c;--border:rgba(255,255,255,0.07);--border2:rgba(255,255,255,0.12);
+    --text:#f8f8f2;--muted:#75715e;--accent:#f92672;--blue:#66d9e8;--gold:#e6db74;--code-bg:#1e1f1c;
+    --surface:#2d2e28;--topbar-bg:rgba(30,31,28,.98);--main-bg:rgba(39,40,34,0.5);
+    --focus-ring:rgba(102,217,232,.35);--focus-glow:rgba(102,217,232,.08);
+    --strong:#f8f8f0;--em:#a6a28c;--code-text:#e6db74;--code-inline-bg:rgba(0,0,0,.3);--pre-text:#f8f8f2;
+  }
+  /* ── Nord theme ── */
+  :root[data-theme="nord"]{
+    --bg:#2e3440;--sidebar:#272c36;--border:rgba(255,255,255,0.07);--border2:rgba(255,255,255,0.12);
+    --text:#eceff4;--muted:#9099aa;--accent:#bf616a;--blue:#81a1c1;--gold:#ebcb8b;--code-bg:#272c36;
+    --surface:#333a47;--topbar-bg:rgba(39,44,54,.98);--main-bg:rgba(46,52,64,0.5);
+    --focus-ring:rgba(129,161,193,.35);--focus-glow:rgba(129,161,193,.08);
+    --strong:#eceff4;--em:#b8c0cc;--code-text:#a3be8c;--code-inline-bg:rgba(0,0,0,.2);--pre-text:#d8dee9;
+  }
+  body{background:var(--bg);color:var(--text);height:100vh;height:100dvh;overflow:hidden;display:flex;}
+  .layout{display:flex;width:100%;height:100vh;height:100dvh;}
+  .sidebar{width:300px;background:var(--sidebar);border-right:1px solid var(--border);display:flex;flex-direction:column;overflow:visible;flex-shrink:0;}
   .sidebar-header{padding:16px 18px 14px;border-bottom:1px solid var(--border);display:flex;align-items:center;gap:10px;}
   .logo{width:32px;height:32px;border-radius:9px;background:linear-gradient(145deg,#e8a030,var(--accent));display:flex;align-items:center;justify-content:center;font-weight:800;font-size:14px;color:#fff;flex-shrink:0;box-shadow:0 2px 8px rgba(233,69,96,.3);}
   .sidebar-header h1{font-size:15px;font-weight:600;}
@@ -15,35 +111,56 @@
   .new-chat-btn:hover{background:rgba(124,185,255,0.13);border-color:rgba(124,185,255,.3);}
   .session-list{flex:1;overflow-y:auto;padding:0 8px 8px;min-height:0;}
   .session-search{padding:4px 10px 8px;flex-shrink:0;}
-  .session-search input{width:100%;background:rgba(255,255,255,.04);border:1px solid rgba(255,255,255,.08);border-radius:8px;color:var(--text);padding:7px 12px;font-size:12px;outline:none;transition:all .15s;}
-  .session-search input:focus{border-color:rgba(124,185,255,.35);background:rgba(255,255,255,.06);box-shadow:0 0 0 2px rgba(124,185,255,.07);}
+  .session-search input{width:100%;background:var(--input-bg);border:1px solid var(--border);border-radius:8px;color:var(--text);padding:7px 12px;font-size:12px;outline:none;transition:all .15s;}
+  .session-search input:focus{border-color:rgba(124,185,255,.35);background:var(--hover-bg);box-shadow:0 0 0 2px rgba(124,185,255,.07);}
   .session-search input::placeholder{color:var(--muted);opacity:.7;}
   /* Inline session title edit */
-  .session-title-input{flex:1;background:rgba(20,32,60,.9);border:1px solid rgba(124,185,255,.6);border-radius:6px;color:var(--text);padding:3px 8px;font-size:13px;outline:none;min-width:0;box-shadow:0 0 0 2px rgba(124,185,255,.15);font-family:inherit;}
-  .session-item{padding:8px 10px 8px 8px;border-radius:8px;cursor:pointer;font-size:13px;color:var(--muted);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;transition:background .15s,color .15s,border-color .15s;display:flex;align-items:center;gap:6px;min-width:0;border-left:2px solid transparent;}
-  .session-item:hover{background:rgba(255,255,255,0.06);color:var(--text);}
-  .session-item.active{background:rgba(124,185,255,0.1);color:var(--blue);border-left:2px solid var(--blue);padding-left:8px;}
+  .session-title-input{flex:1;background:var(--surface);border:1px solid rgba(124,185,255,.6);border-radius:6px;color:var(--text);padding:3px 8px;font-size:13px;outline:none;min-width:0;box-shadow:0 0 0 2px rgba(124,185,255,.15);font-family:inherit;}
+  .session-item{padding:8px 10px 8px 8px;border-radius:0 8px 8px 0;cursor:pointer;font-size:13px;color:var(--muted);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;transition:background .15s,color .15s,border-color .15s;display:flex;align-items:center;gap:6px;min-width:0;border-left:2px solid transparent;position:relative;}
+  .session-item:hover{background:var(--hover-bg);color:var(--text);}
+  .session-item.active{background:rgba(232,160,48,0.12);color:#e8a030;border-left:2px solid #e8a030;padding-left:8px;}
   .session-title{flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}
-  .session-trash{flex-shrink:0;opacity:0;font-size:13px;color:var(--muted);background:none;border:none;cursor:pointer;padding:0 2px;line-height:1;transition:opacity .15s,color .15s;}
-  .session-item:hover .session-trash{opacity:1;}
-  .session-trash:hover{color:var(--accent)!important;}
+  /* ── Session action button overlay ── */
+  .session-actions{position:absolute;right:0;top:0;bottom:0;display:flex;align-items:center;gap:2px;padding:0 6px 0 16px;background:linear-gradient(to right,transparent,var(--sidebar) 12px);opacity:0;pointer-events:none;transition:opacity .15s ease;border-radius:0 8px 8px 0;}
+  .session-item:hover .session-actions{opacity:1;pointer-events:auto;}
+  .session-item.active .session-actions{background:linear-gradient(to right,transparent,rgba(30,22,8,.95) 12px);}
+  .session-actions button{background:none;border:none;color:var(--muted);cursor:pointer;padding:2px 3px;line-height:1;transition:color .12s;display:flex;align-items:center;}
+  .session-actions button:hover{color:var(--text);}
+  .session-actions .act-trash:hover{color:var(--accent);}
+  .session-actions .act-pin.pinned{color:#f5c542;}
+  .session-actions .act-pin.pinned:hover{color:#d4a017;}
+  /* Hide overlay during inline rename */
+  .session-item:has(.session-title-input) .session-actions{display:none;}
   @keyframes newflash{0%{background:rgba(124,185,255,0.22);color:var(--blue);}100%{background:transparent;color:var(--muted);}}
   .session-item.new-flash{animation:newflash 1.4s ease-out forwards;}
-  .toast{position:fixed;bottom:24px;left:50%;transform:translateX(-50%);background:rgba(20,30,50,.95);backdrop-filter:blur(12px);border:1px solid rgba(124,185,255,0.25);color:var(--text);font-size:13px;padding:10px 20px;border-radius:12px;pointer-events:none;opacity:0;transition:opacity .2s,transform .2s;z-index:100;box-shadow:0 4px 20px rgba(0,0,0,.3);letter-spacing:.01em;}
+  /* Collapsible date group headers */
+  .session-date-header{display:flex;align-items:center;gap:5px;font-size:10px;font-weight:700;text-transform:uppercase;letter-spacing:.08em;color:var(--muted);padding:8px 10px 4px;cursor:pointer;user-select:none;opacity:.8;transition:opacity .15s;}
+  .session-date-header:hover{opacity:1;}
+  .session-date-header.pinned{color:#f5c542;}
+  .session-date-caret{font-size:9px;transition:transform .2s;flex-shrink:0;display:inline-block;}
+  .session-date-caret.collapsed{transform:rotate(-90deg);}
+  .toast{position:fixed;bottom:24px;left:50%;transform:translateX(-50%);background:var(--surface);backdrop-filter:blur(12px);border:1px solid rgba(124,185,255,0.25);color:var(--text);font-size:13px;padding:10px 20px;border-radius:12px;pointer-events:none;opacity:0;transition:opacity .2s,transform .2s;z-index:100;box-shadow:0 4px 20px rgba(0,0,0,.3);letter-spacing:.01em;}
   .toast.show{opacity:1;transform:translateX(-50%) translateY(-2px);}
-  .reconnect-banner{display:none;background:#1a2535;border:1px solid rgba(201,168,76,0.4);border-radius:10px;padding:10px 16px;margin:10px auto;max-width:780px;font-size:13px;color:var(--gold);display:none;align-items:center;justify-content:space-between;gap:12px;}
+  .reconnect-banner{display:none;background:var(--surface);border:1px solid rgba(201,168,76,0.4);border-radius:10px;padding:10px 16px;margin:10px auto;max-width:780px;font-size:13px;color:var(--gold);display:none;align-items:center;justify-content:space-between;gap:12px;}
   .reconnect-banner.visible{display:flex;}
   .reconnect-btn{padding:5px 12px;border-radius:7px;font-size:12px;font-weight:600;background:rgba(201,168,76,0.15);border:1px solid rgba(201,168,76,0.4);color:var(--gold);cursor:pointer;}
   .reconnect-btn:hover{background:rgba(201,168,76,0.25);}
+  /* ── Update banner ── */
+  .update-banner{display:none;background:var(--surface);border:1px solid rgba(124,185,255,0.4);border-radius:10px;padding:10px 16px;margin:10px auto;max-width:780px;font-size:13px;color:var(--blue);align-items:center;justify-content:space-between;gap:12px;}
+  .update-banner.visible{display:flex;}
+  .update-btn{padding:5px 12px;border-radius:7px;font-size:12px;font-weight:600;background:rgba(124,185,255,0.1);border:1px solid rgba(124,185,255,0.3);color:var(--blue);cursor:pointer;transition:background .15s;}
+  .update-btn:hover{background:rgba(124,185,255,0.2);}
+  .update-primary{background:rgba(124,185,255,0.2);border-color:rgba(124,185,255,0.5);}
+  .update-btn:disabled{opacity:0.5;cursor:not-allowed;}
   /* ── Approval card ── */
   .approval-card{display:none;max-width:780px;margin:0 auto 0;padding:0 20px 12px;}
   .approval-card.visible{display:block;}
-  .approval-inner{background:rgba(20,30,50,.95);backdrop-filter:blur(8px);border:1px solid rgba(233,69,96,0.35);border-radius:14px;padding:14px 16px;}
+  .approval-inner{background:var(--surface);backdrop-filter:blur(8px);border:1px solid rgba(233,69,96,0.35);border-radius:14px;padding:14px 16px;}
   .approval-header{display:flex;align-items:center;gap:8px;margin-bottom:10px;font-size:13px;font-weight:600;color:#e94560;}
   .approval-desc{font-size:12px;color:var(--muted);margin-bottom:8px;}
-  .approval-cmd{background:var(--code-bg);border:1px solid rgba(255,255,255,.08);border-radius:8px;padding:8px 12px;font-family:"SF Mono",ui-monospace,monospace;font-size:12px;color:#e2e8f0;white-space:pre-wrap;word-break:break-all;margin-bottom:12px;max-height:120px;overflow-y:auto;}
+  .approval-cmd{background:var(--code-bg);border:1px solid var(--border);border-radius:8px;padding:8px 12px;font-family:"SF Mono",ui-monospace,monospace;font-size:12px;color:var(--pre-text);white-space:pre-wrap;word-break:break-all;margin-bottom:12px;max-height:120px;overflow-y:auto;}
   .approval-btns{display:flex;gap:8px;flex-wrap:wrap;}
-  .approval-btn{padding:6px 14px;border-radius:8px;font-size:12px;font-weight:600;border:1px solid var(--border2);background:rgba(255,255,255,0.06);color:var(--text);cursor:pointer;transition:all .15s;}
+  .approval-btn{padding:6px 14px;border-radius:8px;font-size:12px;font-weight:600;border:1px solid var(--border2);background:var(--hover-bg);color:var(--text);cursor:pointer;transition:all .15s;}
   .approval-btn:hover{background:rgba(255,255,255,0.12);}
   .approval-btn.once{border-color:rgba(124,185,255,0.5);color:var(--blue);}
   .approval-btn.once:hover{background:rgba(124,185,255,0.15);}
@@ -55,7 +172,7 @@
   .sidebar-nav{display:flex;border-bottom:1px solid var(--border);flex-shrink:0;padding:6px 8px 0;gap:2px;}
   .nav-tab{flex:1;padding:10px 4px 8px;font-size:20px;text-align:center;cursor:pointer;color:var(--muted);border:none;background:none;transition:color .15s;border-bottom:2px solid transparent;white-space:nowrap;overflow:hidden;position:relative;}
   .nav-tab:hover{color:var(--text);}
-  .nav-tab:hover::after{content:attr(data-label);position:absolute;bottom:calc(100% + 8px);left:50%;transform:translateX(-50%);background:rgba(15,22,40,.98);border:1px solid rgba(124,185,255,0.3);color:var(--blue);font-size:12px;font-weight:700;letter-spacing:.02em;padding:5px 11px;border-radius:7px;white-space:nowrap;pointer-events:none;z-index:50;box-shadow:0 4px 12px rgba(0,0,0,.3);}
+  .nav-tab:hover::after{content:attr(data-label);position:absolute;bottom:calc(100% + 8px);left:50%;transform:translateX(-50%);background:var(--surface);border:1px solid rgba(124,185,255,0.3);color:var(--blue);font-size:12px;font-weight:700;letter-spacing:.02em;padding:5px 11px;border-radius:7px;white-space:nowrap;pointer-events:none;z-index:50;box-shadow:0 4px 12px rgba(0,0,0,.3);}
   .nav-tab.active{color:var(--blue);}
   .nav-tab.active::before{content:'';position:absolute;bottom:0;left:50%;transform:translateX(-50%);width:20px;height:2px;background:var(--blue);border-radius:2px 2px 0 0;}
   /* Panel content areas (swapped by tab) */
@@ -63,7 +180,7 @@
   .panel-view.active{display:flex;}
   /* Cron panel */
   .cron-list{flex:1;overflow-y:auto;padding:8px;}
-  .cron-item{border-radius:10px;border:1px solid rgba(255,255,255,.08);margin-bottom:6px;overflow:hidden;transition:border-color .15s,background .15s;background:rgba(255,255,255,.02);}
+  .cron-item{border-radius:10px;border:1px solid var(--border);margin-bottom:6px;overflow:hidden;transition:border-color .15s,background .15s;background:rgba(255,255,255,.02);}
   .cron-item:hover{border-color:var(--border2);}
   .cron-header{display:flex;align-items:center;gap:8px;padding:9px 11px;cursor:pointer;}
   .cron-name{flex:1;font-size:13px;color:var(--text);font-weight:500;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}
@@ -86,14 +203,14 @@
   .cron-last-header{font-size:10px;font-weight:600;text-transform:uppercase;letter-spacing:.06em;color:var(--muted);margin-bottom:4px;}
   /* Skills panel */
   .skills-search{padding:8px;flex-shrink:0;}
-  .skills-search input{width:100%;background:rgba(255,255,255,.06);border:1px solid var(--border2);border-radius:7px;color:var(--text);padding:6px 10px;font-size:12px;outline:none;}
+  .skills-search input{width:100%;background:var(--hover-bg);border:1px solid var(--border2);border-radius:7px;color:var(--text);padding:6px 10px;font-size:12px;outline:none;}
   .skills-search input::placeholder{color:var(--muted);}
   .skills-list{flex:1;overflow-y:auto;padding:0 8px 8px;}
   .skills-category{margin-bottom:4px;}
   .skills-cat-header{font-size:10px;font-weight:700;text-transform:uppercase;letter-spacing:.08em;color:var(--muted);padding:8px 6px 4px;cursor:pointer;display:flex;align-items:center;gap:4px;}
   .skills-cat-header:hover{color:var(--text);}
   .skill-item{padding:7px 10px;border-radius:7px;cursor:pointer;font-size:12px;color:var(--muted);display:flex;align-items:flex-start;gap:6px;transition:all .12s;line-height:1.4;}
-  .skill-item:hover{background:rgba(255,255,255,.06);color:var(--text);}
+  .skill-item:hover{background:var(--hover-bg);color:var(--text);}
   .skill-item.active{background:rgba(124,185,255,.1);color:var(--blue);}
   .skill-name{font-weight:500;flex-shrink:0;}
   .skill-desc{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;flex:1;font-size:11px;opacity:.7;}
@@ -105,23 +222,23 @@
   .memory-content{font-size:12px;line-height:1.7;color:var(--text);}
   .memory-content p{margin-bottom:6px;}
   .memory-empty{color:var(--muted);font-size:12px;font-style:italic;}
-  .sidebar-bottom{border-top:1px solid var(--border);padding:12px 14px;flex-shrink:0;}
+  .sidebar-bottom{border-top:1px solid var(--border);padding:12px 14px;flex-shrink:0;position:relative;z-index:10;overflow:visible;}
   .field-label{font-size:10px;font-weight:700;text-transform:uppercase;letter-spacing:.08em;color:var(--muted);margin-bottom:5px;opacity:.8;}
-  select{width:100%;background:rgba(255,255,255,0.04);border:1px solid rgba(255,255,255,.1);border-radius:8px;color:var(--text);padding:7px 28px 7px 10px;font-size:12px;outline:none;appearance:none;margin-bottom:6px;cursor:pointer;background-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='6' viewBox='0 0 10 6'%3E%3Cpath d='M1 1l4 4 4-4' stroke='%238888aa' stroke-width='1.5' fill='none' stroke-linecap='round'/%3E%3C/svg%3E");background-repeat:no-repeat;background-position:right 10px center;}
+  select{width:100%;background:var(--input-bg);border:1px solid var(--border2);border-radius:8px;color:var(--text);padding:7px 28px 7px 10px;font-size:12px;outline:none;appearance:none;margin-bottom:6px;cursor:pointer;background-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='6' viewBox='0 0 10 6'%3E%3Cpath d='M1 1l4 4 4-4' stroke='%238888aa' stroke-width='1.5' fill='none' stroke-linecap='round'/%3E%3C/svg%3E");background-repeat:no-repeat;background-position:right 10px center;}
   select:focus{border-color:rgba(124,185,255,.4);box-shadow:0 0 0 2px rgba(124,185,255,.08);}
   optgroup{color:var(--muted);font-size:11px;font-weight:700;}
-  option{background:#1a1a2e;color:var(--text);padding:6px;}
+  option{background:var(--bg);color:var(--text);padding:6px;}
   .sidebar-actions{display:flex;gap:6px;}
-  .sm-btn{flex:1;padding:7px 0;border-radius:8px;font-size:11px;font-weight:500;background:rgba(255,255,255,0.04);border:1px solid rgba(255,255,255,.08);color:var(--muted);cursor:pointer;transition:all .15s;text-align:center;letter-spacing:.02em;}
+  .sm-btn{flex:1;padding:7px 0;border-radius:8px;font-size:11px;font-weight:500;background:var(--input-bg);border:1px solid var(--border);color:var(--muted);cursor:pointer;transition:all .15s;text-align:center;letter-spacing:.02em;}
   .sm-btn:hover{background:rgba(255,255,255,0.09);color:var(--text);border-color:rgba(255,255,255,.15);}
-  .main{flex:1;display:flex;flex-direction:column;overflow:hidden;min-width:0;background:rgba(26,26,46,0.5);}
-  .topbar{padding:12px 20px;border-bottom:1px solid var(--border);background:rgba(22,33,62,.98);backdrop-filter:blur(12px);display:flex;align-items:center;justify-content:space-between;flex-shrink:0;}
+  .main{flex:1;display:flex;flex-direction:column;overflow:hidden;min-width:0;background:var(--main-bg);}
+  .topbar{padding:12px 20px;border-bottom:1px solid var(--border);background:var(--topbar-bg);backdrop-filter:blur(12px);display:flex;align-items:center;justify-content:space-between;flex-shrink:0;position:relative;z-index:10;}
   .topbar-title{font-size:15px;font-weight:600;letter-spacing:-.01em;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;}
   .topbar-meta{font-size:11px;color:var(--muted);margin-top:3px;opacity:.75;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;}
   .topbar-chips{display:flex;gap:6px;align-items:center;flex-shrink:0;}
-  .chip{font-size:11px;padding:4px 10px;border-radius:999px;background:rgba(255,255,255,0.05);border:1px solid rgba(255,255,255,.1);color:var(--muted);font-weight:500;}
+  .chip{font-size:11px;padding:4px 10px;border-radius:999px;background:rgba(255,255,255,0.05);border:1px solid var(--border2);color:var(--muted);font-weight:500;}
   .chip.model{color:var(--blue);border-color:rgba(124,185,255,0.35);background:rgba(124,185,255,0.1);}
-  .messages{flex:1;overflow-y:auto;display:flex;flex-direction:column;min-height:0;}
+  .messages{flex:1;overflow-y:auto;display:flex;flex-direction:column;min-height:0;position:relative;z-index:0;}
   .messages-inner{max-width:800px;margin:0 auto;width:100%;padding:20px 24px 32px;display:flex;flex-direction:column;}
   .msg-row{padding:10px 0;}
   .msg-row+.msg-row{border-top:none;}
@@ -136,11 +253,11 @@
   .msg-body ul,.msg-body ol{margin:6px 0 10px 20px;}.msg-body li{margin-bottom:3px;}
   .msg-body h1,.msg-body h2,.msg-body h3{margin:16px 0 6px;font-weight:600;}
   .msg-body h1{font-size:18px;}.msg-body h2{font-size:16px;}.msg-body h3{font-size:14px;}
-  .msg-body strong{color:#fff;font-weight:600;}.msg-body em{color:#c9c9e8;font-style:italic;}
-  .msg-body code{font-family:"SF Mono","Fira Code",ui-monospace,monospace;font-size:12.5px;background:rgba(0,0,0,.35);padding:1px 5px;border-radius:4px;color:#f0c27f;}
-  .msg-body pre{background:var(--code-bg);border:1px solid rgba(255,255,255,.08);border-radius:10px;padding:14px 16px;overflow-x:auto;margin:10px 0;}
-  .msg-body pre code{background:none;padding:0;border-radius:0;color:#e2e8f0;font-size:13px;line-height:1.6;}
-  .pre-header{font-size:10px;font-weight:600;text-transform:uppercase;letter-spacing:.06em;color:var(--muted);padding:8px 16px 8px;background:rgba(255,255,255,.04);border-radius:10px 10px 0 0;border:1px solid rgba(255,255,255,.08);border-bottom:1px solid rgba(255,255,255,.05);display:flex;align-items:center;gap:6px;}
+  .msg-body strong{color:var(--strong);font-weight:600;}.msg-body em{color:var(--em);font-style:italic;}
+  .msg-body code{font-family:"SF Mono","Fira Code",ui-monospace,monospace;font-size:12.5px;background:var(--code-inline-bg);padding:1px 5px;border-radius:4px;color:var(--code-text);}
+  .msg-body pre{background:var(--code-bg);border:1px solid var(--border);border-radius:10px;padding:14px 16px;overflow-x:auto;margin:10px 0;}
+  .msg-body pre code{background:none;padding:0;border-radius:0;color:var(--pre-text);font-size:13px;line-height:1.6;}
+  .pre-header{font-size:10px;font-weight:600;text-transform:uppercase;letter-spacing:.06em;color:var(--muted);padding:8px 16px 8px;background:var(--input-bg);border-radius:10px 10px 0 0;border:1px solid var(--border);border-bottom:1px solid var(--border);display:flex;align-items:center;gap:6px;}
   .pre-header::before{content:'';width:8px;height:8px;border-radius:50%;background:var(--muted);opacity:.4;}
   .pre-header+pre{border-radius:0 0 10px 10px;border-top:none;margin-top:0;}
   .msg-body blockquote{border-left:3px solid var(--blue);padding-left:14px;color:var(--muted);font-style:italic;margin:10px 0;}
@@ -157,11 +274,11 @@
   .empty-state h2{font-size:20px;color:var(--text);font-weight:700;letter-spacing:-.02em;}
   .empty-state p{font-size:14px;text-align:center;max-width:320px;}
   .suggestion-grid{display:flex;flex-direction:column;gap:8px;margin-top:12px;width:100%;max-width:380px;}
-  .suggestion{padding:11px 14px;background:rgba(255,255,255,0.04);border:1px solid rgba(255,255,255,.08);border-radius:10px;font-size:13px;color:var(--muted);cursor:pointer;transition:all .15s;text-align:left;}
+  .suggestion{padding:11px 14px;background:var(--input-bg);border:1px solid var(--border);border-radius:10px;font-size:13px;color:var(--muted);cursor:pointer;transition:all .15s;text-align:left;}
   .suggestion:hover{background:rgba(124,185,255,0.07);color:var(--text);border-color:rgba(124,185,255,.3);transform:translateX(2px);}
   /* ── Composer ── */
   .composer-wrap{border-top:1px solid var(--border);padding:12px 20px 16px;background:var(--bg);flex-shrink:0;}
-  .composer-box{max-width:780px;margin:0 auto;background:rgba(255,255,255,0.04);border:1px solid rgba(255,255,255,.12);border-radius:16px;display:flex;flex-direction:column;transition:border-color .2s,box-shadow .2s;position:relative;}
+  .composer-box{max-width:780px;margin:0 auto;background:var(--input-bg);border:1px solid var(--border2);border-radius:16px;display:flex;flex-direction:column;transition:border-color .2s,box-shadow .2s;position:relative;}
   .composer-box:focus-within{border-color:rgba(124,185,255,0.5);box-shadow:0 0 0 3px rgba(124,185,255,0.08);}
   .composer-wrap.drag-over .composer-box{border-color:var(--blue);background:rgba(124,185,255,0.06);}
   .drop-hint{display:none;position:absolute;inset:0;align-items:center;justify-content:center;background:rgba(124,185,255,0.08);border:2px dashed var(--blue);border-radius:14px;font-size:14px;color:var(--blue);pointer-events:none;z-index:10;flex-direction:column;gap:8px;}
@@ -175,20 +292,36 @@
   textarea#msg::placeholder{color:var(--muted);}
   .composer-footer{display:flex;align-items:center;justify-content:space-between;padding:6px 10px 10px;}
   .composer-left{display:flex;gap:2px;align-items:center;}
+  /* Context usage indicator */
+  .ctx-indicator{display:flex;align-items:center;gap:6px;padding:2px 4px;flex-shrink:1;min-width:0;}
+  .ctx-bar-wrap{width:70px;height:5px;border-radius:3px;background:rgba(255,255,255,.08);overflow:hidden;flex-shrink:0;}
+  .ctx-bar{display:block;height:100%;border-radius:3px;transition:width .4s ease,background .4s ease;min-width:2px;background:var(--blue);}
+  .ctx-bar.ctx-mid{background:#e6a817;}
+  .ctx-bar.ctx-high{background:#e05252;}
+  .ctx-label{font-size:9px;color:var(--muted);white-space:nowrap;font-variant-numeric:tabular-nums;}
   .composer-right{display:flex;gap:6px;align-items:center;}
   .icon-btn{width:34px;height:34px;border-radius:8px;background:none;border:none;color:var(--muted);cursor:pointer;display:flex;align-items:center;justify-content:center;font-size:16px;transition:all .15s;}
   .icon-btn{opacity:.75;}
   .icon-btn:hover{background:rgba(255,255,255,.08);color:var(--text);opacity:1;}
+  .mic-btn{transition:color .15s,background .15s;}
+  .mic-btn.recording{color:#e94560;background:rgba(233,69,96,.12);animation:mic-pulse 1.2s ease-in-out infinite;}
+  @keyframes mic-pulse{0%,100%{box-shadow:0 0 0 0 rgba(233,69,96,.3);}50%{box-shadow:0 0 0 6px rgba(233,69,96,0);}}
+  .mic-status{font-size:11px;color:#e94560;padding:4px 12px;display:flex;align-items:center;gap:6px;}
+  .mic-dot{width:6px;height:6px;border-radius:50%;background:#e94560;animation:mic-pulse 1.2s ease-in-out infinite;flex-shrink:0;}
   .status-text{font-size:11px;color:var(--muted);padding-left:4px;}
-  .send-btn{padding:7px 18px;border-radius:10px;font-size:13px;font-weight:600;background:linear-gradient(135deg,#5ba8f5,#7cb9ff);border:none;color:#0a1628;cursor:pointer;display:flex;align-items:center;gap:6px;transition:all .15s;flex-shrink:0;letter-spacing:.01em;}
-  .send-btn:hover{background:linear-gradient(135deg,#7cb9ff,#a0d0ff);transform:translateY(-1px);}
-  .send-btn:active{transform:translateY(0);}
-  .send-btn:disabled{opacity:.4;cursor:not-allowed;}
-  .upload-bar-wrap{display:none;height:3px;background:rgba(255,255,255,.06);border-radius:0 0 16px 16px;overflow:hidden;}
+  .send-btn{width:34px;height:34px;border-radius:50%;background:#7cb9ff;border:none;color:#0a1628;cursor:pointer;display:flex;align-items:center;justify-content:center;flex-shrink:0;transition:background .15s,transform .15s,box-shadow .15s;box-shadow:0 2px 8px rgba(124,185,255,.35);}
+  .send-btn:hover{background:#a0d0ff;transform:scale(1.08);box-shadow:0 4px 14px rgba(124,185,255,.5);}
+  .send-btn:active{transform:scale(0.95);box-shadow:0 1px 4px rgba(124,185,255,.25);}
+  .send-btn:disabled{opacity:.35;cursor:not-allowed;transform:none;box-shadow:none;}
+  .send-btn.visible{animation:send-pop-in .18s cubic-bezier(.34,1.56,.64,1) forwards;}
+  @keyframes send-pop-in{from{opacity:0;transform:scale(.55);}to{opacity:1;transform:scale(1);}}
+  .upload-bar-wrap{display:none;height:3px;background:var(--hover-bg);border-radius:0 0 16px 16px;overflow:hidden;}
   .upload-bar-wrap.active{display:block;}
   .upload-bar{height:100%;background:linear-gradient(90deg,var(--blue),#a0d0ff);width:0%;transition:width .3s ease;}
-  .rightpanel{width:300px;background:var(--sidebar);border-left:1px solid rgba(255,255,255,.06);display:flex;flex-direction:column;overflow:hidden;flex-shrink:0;}
+  .rightpanel{width:300px;background:var(--sidebar);border-left:1px solid var(--border);display:flex;flex-direction:column;overflow:hidden;flex-shrink:0;}
   .panel-header{padding:12px 16px;border-bottom:1px solid var(--border);font-size:11px;font-weight:600;color:var(--muted);text-transform:uppercase;letter-spacing:.1em;display:flex;align-items:center;justify-content:space-between;}
+  .git-badge{font-size:9px;font-weight:600;color:var(--muted);background:var(--hover-bg);padding:2px 7px;border-radius:4px;letter-spacing:.02em;margin-left:auto;margin-right:4px;white-space:nowrap;font-family:'SF Mono',ui-monospace,monospace;}
+  .git-badge.dirty{color:var(--gold);background:rgba(201,168,76,.1);}
   .panel-actions{display:flex;gap:4px;}
   .panel-icon-btn{width:24px;height:24px;background:none;border:none;color:var(--muted);cursor:pointer;border-radius:5px;font-size:13px;display:flex;align-items:center;justify-content:center;transition:all .15s;}
   .panel-icon-btn:hover{background:rgba(255,255,255,.08);color:var(--text);}
@@ -197,10 +330,20 @@
   .file-action-btn{width:20px;height:20px;background:rgba(0,0,0,.4);border:none;border-radius:4px;color:var(--muted);cursor:pointer;font-size:11px;display:flex;align-items:center;justify-content:center;}
   .file-action-btn:hover{color:var(--accent);}
   .close-preview{cursor:pointer;opacity:.6;}.close-preview:hover{opacity:1;}
+  /* Breadcrumb navigation */
+  .breadcrumb-bar{display:flex;align-items:center;gap:2px;padding:6px 12px;font-size:12px;border-bottom:1px solid var(--border);flex-shrink:0;overflow:hidden;white-space:nowrap;}
+  .breadcrumb-seg{padding:1px 3px;border-radius:3px;}
+  .breadcrumb-link{color:var(--muted);cursor:pointer;transition:color .12s;}
+  .breadcrumb-link:hover{color:var(--text);background:var(--hover-bg);}
+  .breadcrumb-current{color:var(--text);font-weight:500;}
+  .breadcrumb-sep{color:var(--border);margin:0 1px;font-size:11px;}
   .file-tree{flex:1;overflow-y:auto;padding:8px;}
   .file-item{display:flex;align-items:center;gap:6px;padding:6px 10px;border-radius:7px;cursor:pointer;font-size:12px;color:var(--muted);transition:all .12s;min-width:0;}
   .file-item:hover{background:rgba(255,255,255,.07);color:var(--text);}
   .file-item.active{background:rgba(124,185,255,.12);color:var(--blue);}
+  .file-tree-toggle{font-size:10px;color:var(--muted);flex-shrink:0;width:10px;text-align:center;line-height:1;}
+  .file-item.file-empty{color:var(--muted);opacity:.5;font-style:italic;cursor:default;font-size:11px;}
+  .file-item.file-empty:hover{background:none;color:var(--muted);}
   .preview-area{flex:1;overflow:auto;padding:14px;flex-direction:column;gap:8px;display:none;opacity:0;transition:opacity .15s;}
   .preview-area.visible{display:flex;opacity:1;}
   .preview-path{font-size:11px;color:var(--muted);padding-bottom:8px;border-bottom:1px solid var(--border);flex-shrink:0;}
@@ -211,15 +354,15 @@
   /* Markdown rendered preview */
   .preview-md{font-size:13px;line-height:1.7;color:var(--text);flex:1;overflow-y:auto;min-height:0;}
   .preview-md p{margin-bottom:10px;}.preview-md p:last-child{margin-bottom:0;}
-  .preview-md h1{font-size:18px;font-weight:700;margin:16px 0 8px;color:#fff;border-bottom:1px solid var(--border);padding-bottom:6px;}
-  .preview-md h2{font-size:15px;font-weight:600;margin:14px 0 6px;color:#fff;}
+  .preview-md h1{font-size:18px;font-weight:700;margin:16px 0 8px;color:var(--strong);border-bottom:1px solid var(--border);padding-bottom:6px;}
+  .preview-md h2{font-size:15px;font-weight:600;margin:14px 0 6px;color:var(--strong);}
   .preview-md h3{font-size:13px;font-weight:600;margin:12px 0 4px;color:#e8e8f0;}
   .preview-md ul,.preview-md ol{margin:4px 0 10px 18px;}.preview-md li{margin-bottom:3px;}
-  .preview-md code{font-family:"SF Mono",ui-monospace,monospace;font-size:11.5px;background:rgba(0,0,0,.35);padding:1px 5px;border-radius:4px;color:#f0c27f;}
-  .preview-md pre{background:var(--code-bg);border:1px solid rgba(255,255,255,.08);border-radius:8px;padding:10px 12px;overflow-x:auto;margin:8px 0;}
-  .preview-md pre code{background:none;padding:0;color:#e2e8f0;font-size:11.5px;line-height:1.55;}
+  .preview-md code{font-family:"SF Mono",ui-monospace,monospace;font-size:11.5px;background:var(--code-inline-bg);padding:1px 5px;border-radius:4px;color:var(--code-text);}
+  .preview-md pre{background:var(--code-bg);border:1px solid var(--border);border-radius:8px;padding:10px 12px;overflow-x:auto;margin:8px 0;}
+  .preview-md pre code{background:none;padding:0;color:var(--pre-text);font-size:11.5px;line-height:1.55;}
   .preview-md blockquote{border-left:3px solid var(--blue);padding-left:12px;color:var(--muted);font-style:italic;margin:8px 0;}
-  .preview-md strong{color:#fff;font-weight:600;}.preview-md em{color:#c9c9e8;}
+  .preview-md strong{color:var(--strong);font-weight:600;}.preview-md em{color:var(--em);}
   .preview-md a{color:var(--blue);text-decoration:underline;}
   .preview-md hr{border:none;border-top:1px solid var(--border);margin:12px 0;}
   .preview-md table{border-collapse:collapse;width:100%;margin:8px 0;font-size:12px;}
@@ -235,17 +378,98 @@
   ::-webkit-scrollbar-track{background:transparent}
   ::-webkit-scrollbar-thumb{background:rgba(255,255,255,.1);border-radius:99px;transition:background .2s}
   ::-webkit-scrollbar-thumb:hover{background:rgba(255,255,255,.22)}
-  @media(max-width:900px){.rightpanel{display:none}}@media(max-width:640px){.sidebar{display:none}}
+  /* ── Desktop: hide mobile-only elements ── */
+  .mobile-hamburger{display:none;}
+  .mobile-files-btn{display:none!important;}
+  .mobile-overlay{display:none;}
+  .mobile-bottom-nav{display:none;}
+
+  @media(max-width:900px){.rightpanel{display:none}.mobile-files-btn{display:inline-flex!important;}}
+
+  @media(max-width:640px){
+    /* ── Sidebar: slide-in overlay instead of hidden ── */
+    .sidebar{position:fixed;left:-300px;top:0;bottom:0;width:280px;z-index:200;
+      transition:left .25s ease;box-shadow:4px 0 24px rgba(0,0,0,.4);}
+    .sidebar.mobile-open{left:0;}
+    .sidebar .resize-handle{display:none;}
+    /* Hamburger button */
+    .mobile-hamburger{display:flex;align-items:center;justify-content:center;
+      background:none;border:none;color:var(--muted);cursor:pointer;padding:4px;
+      flex-shrink:0;-webkit-tap-highlight-color:transparent;}
+    .mobile-hamburger:hover{color:var(--text);}
+    /* Overlay backdrop */
+    .mobile-overlay{display:none;position:fixed;inset:0;background:rgba(0,0,0,.5);
+      z-index:199;-webkit-tap-highlight-color:transparent;}
+    .mobile-overlay.visible{display:block;}
+    /* Files button in topbar */
+    .mobile-files-btn{display:inline-flex!important;}
+    /* Right panel: slide-over from right */
+    .rightpanel{display:flex!important;position:fixed;right:-320px;top:0;bottom:0;
+      width:300px;z-index:200;transition:right .25s ease;
+      box-shadow:-4px 0 24px rgba(0,0,0,.4);}
+    .rightpanel.mobile-open{right:0;}
+    .rightpanel .resize-handle{display:none;}
+    /* Bottom navigation bar */
+    .mobile-bottom-nav{display:flex;position:fixed;bottom:0;left:0;right:0;
+      background:var(--sidebar);border-top:1px solid var(--border);
+      z-index:150;padding:4px 0 env(safe-area-inset-bottom,0);
+      justify-content:space-around;align-items:center;}
+    .mobile-nav-btn{display:flex;flex-direction:column;align-items:center;gap:2px;
+      background:none;border:none;color:var(--muted);font-size:9px;padding:6px 4px;
+      cursor:pointer;min-width:44px;min-height:44px;justify-content:center;
+      -webkit-tap-highlight-color:transparent;transition:color .15s;}
+    .mobile-nav-btn.active{color:var(--blue);}
+    .mobile-nav-btn:hover{color:var(--text);}
+    .mobile-nav-btn svg{flex-shrink:0;}
+    /* Hide sidebar nav tabs (replaced by bottom nav) */
+    .sidebar-nav{display:none;}
+    /* Hide sidebar bottom section on mobile (model select, workspace) */
+    .sidebar-bottom{display:none;}
+    /* Topbar adjustments */
+    .topbar{padding:8px 12px;gap:8px;}
+    .topbar-title{font-size:14px;}
+    .topbar-meta{display:none;}
+    .topbar-chips{flex-wrap:nowrap;gap:4px;overflow-x:auto;-webkit-overflow-scrolling:touch;}
+    .topbar-chips .chip,.topbar-chips .ws-chip,.topbar-chips button{font-size:11px!important;padding:3px 8px!important;white-space:nowrap;}
+    /* Messages area — account for bottom nav */
+    .messages{padding-bottom:60px;}
+    .messages-inner{padding:12px 10px 20px;}
+    .msg-body{padding-left:0;max-width:100%;}
+    .msg-role{font-size:12px;}
+    /* Composer — above bottom nav */
+    .composer-wrap{padding:8px 10px 12px!important;margin-bottom:56px;}
+    .composer-box{border-radius:12px;}
+    .composer-box textarea{font-size:16px;min-height:40px;}
+    .send-btn{width:32px;height:32px;}
+    /* Touch targets — minimum 44px */
+    .icon-btn,.mic-btn{min-width:44px;min-height:44px;}
+    .session-item{min-height:44px;padding:10px 12px;}
+    /* Empty state */
+    .empty-state h2{font-size:18px;}
+    .empty-state p{font-size:13px;}
+    .suggestion-grid{max-width:100%!important;}
+    .suggestion{font-size:12px;padding:10px 12px;}
+    /* Approval card */
+    .approval-card{padding:0 10px 8px;}
+    .approval-btns{gap:6px;}
+    .approval-btn{padding:8px 12px;font-size:12px;min-height:44px;}
+    /* Tool cards */
+    .tool-card{margin-left:0!important;font-size:12px;}
+    /* Settings modal */
+    .settings-panel{width:95vw;max-width:95vw;min-height:min(580px,88vh);max-height:92vh;}
+    /* Login page responsive */
+    .card{width:90vw;max-width:320px;padding:28px 24px;}
+  }
 
 /* ── Workspace dropdown (topbar) ── */
 .ws-chip{user-select:none;}
-.ws-dropdown{display:none;position:absolute;top:calc(100% + 6px);right:0;min-width:240px;background:#1a2535;border:1px solid var(--border2);border-radius:10px;box-shadow:0 8px 24px rgba(0,0,0,.4);z-index:200;overflow:hidden;max-height:320px;overflow-y:auto;}
+.ws-dropdown{display:none;position:absolute;bottom:calc(100% + 4px);left:0;right:0;min-width:200px;background:var(--surface);border:1px solid var(--border2);border-radius:10px;box-shadow:0 -4px 24px rgba(0,0,0,.4);z-index:200;overflow:hidden;max-height:320px;overflow-y:auto;}
 .ws-dropdown.open{display:block;}
-.ws-opt{padding:9px 14px;cursor:pointer;transition:background .12s;}
+.ws-opt{padding:10px 14px;cursor:pointer;transition:background .12s;display:flex;flex-direction:column;gap:4px;align-items:flex-start;}
 .ws-opt:hover{background:rgba(255,255,255,.07);}
 .ws-opt.active{background:rgba(124,185,255,.1);}
-.ws-opt-name{font-size:13px;color:var(--text);font-weight:500;}
-.ws-opt-path{font-size:11px;color:var(--muted);overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}
+.ws-opt-name{display:block;font-size:13px;color:var(--text);font-weight:500;line-height:1.25;white-space:normal;overflow:hidden;text-overflow:ellipsis;}
+.ws-opt-path{display:block;font-size:10px;color:var(--muted);line-height:1.3;overflow:hidden;text-overflow:ellipsis;white-space:normal;opacity:.72;word-break:break-word;}
 .ws-divider{height:1px;background:var(--border);margin:4px 0;}
 .ws-manage{color:var(--muted);font-size:12px;}
 /* ── Workspace management panel ── */
@@ -257,6 +481,33 @@
 .ws-row-actions{display:flex;gap:4px;flex-shrink:0;}
 .ws-action-btn{padding:4px 9px;border-radius:6px;font-size:11px;font-weight:600;border:1px solid var(--border2);background:rgba(255,255,255,.05);color:var(--muted);cursor:pointer;transition:all .15s;white-space:nowrap;}
 .ws-action-btn:hover{background:rgba(255,255,255,.1);color:var(--text);}
+/* ── Profile dropdown + management panel ── */
+.profile-chip{user-select:none;color:rgba(168,139,250,.9)!important;}
+.profile-dropdown{display:none;position:absolute;top:calc(100% + 6px);right:0;min-width:260px;background:var(--surface);border:1px solid var(--border2);border-radius:10px;box-shadow:0 8px 24px rgba(0,0,0,.4);z-index:200;overflow:hidden;max-height:380px;overflow-y:auto;}
+.profile-dropdown.open{display:block;}
+.profile-opt{padding:9px 14px;cursor:pointer;transition:background .12s;}
+.profile-opt:hover{background:rgba(255,255,255,.07);}
+.profile-opt.active{background:rgba(168,139,250,.08);}
+.profile-opt-name{font-size:13px;color:var(--text);font-weight:500;}
+.profile-opt-meta{font-size:11px;color:var(--muted);margin-top:2px;}
+.profile-opt-badge{display:inline-block;width:7px;height:7px;border-radius:50%;margin-right:5px;vertical-align:middle;}
+.profile-opt-badge.running{background:#4caf50;box-shadow:0 0 4px rgba(76,175,80,.5);}
+.profile-opt-badge.stopped{background:rgba(255,255,255,.2);}
+.profile-card{padding:10px 0;border-bottom:1px solid var(--border);}
+.profile-card:last-of-type{border-bottom:none;}
+.profile-card-header{display:flex;align-items:center;justify-content:space-between;gap:8px;}
+.profile-card-name{font-size:13px;font-weight:600;color:var(--text);}
+.profile-card-name.is-active{color:rgba(168,139,250,.9);}
+.profile-card-meta{font-size:11px;color:var(--muted);margin-top:3px;padding-left:12px;}
+.profile-card-actions{display:flex;gap:4px;flex-shrink:0;}
+/* ── Slash command autocomplete dropdown ── */
+.cmd-dropdown{display:none;position:absolute;bottom:100%;left:0;right:0;background:var(--surface);border:1px solid var(--border2);border-radius:10px;box-shadow:0 -8px 24px rgba(0,0,0,.4);z-index:200;max-height:240px;overflow-y:auto;margin-bottom:4px;}
+.cmd-dropdown.open{display:block;}
+.cmd-item{padding:8px 14px;cursor:pointer;transition:background .12s;}
+.cmd-item:hover,.cmd-item.selected{background:rgba(255,255,255,.07);}
+.cmd-item-name{font-size:13px;color:var(--text);font-weight:500;}
+.cmd-item-arg{color:var(--muted);font-weight:400;font-style:italic;}
+.cmd-item-desc{font-size:11px;color:var(--muted);margin-top:1px;}
 .ws-action-btn.danger:hover{background:rgba(233,69,96,.12);color:var(--accent);border-color:rgba(233,69,96,.3);}
 .ws-add-row{display:flex;gap:8px;align-items:center;padding:10px 0 4px;}
 /* ── Message action buttons (copy, edit, retry) ── */
@@ -270,7 +521,7 @@
 .msg-edit-bar{display:flex;gap:8px;margin-top:8px;margin-bottom:4px;}
 .msg-edit-send{background:var(--blue);color:#fff;border:none;border-radius:7px;padding:6px 16px;font-size:13px;font-weight:600;cursor:pointer;transition:opacity .15s;}
 .msg-edit-send:hover{opacity:.85;}
-.msg-edit-cancel{background:rgba(255,255,255,.06);color:var(--muted);border:1px solid var(--border2);border-radius:7px;padding:6px 12px;font-size:13px;cursor:pointer;transition:background .15s;}
+.msg-edit-cancel{background:var(--hover-bg);color:var(--muted);border:1px solid var(--border2);border-radius:7px;padding:6px 12px;font-size:13px;cursor:pointer;transition:background .15s;}
 .msg-edit-cancel:hover{background:rgba(255,255,255,.1);}
 
 /* ── Clear conversation chip ── */
@@ -312,7 +563,7 @@
 .msg-role > span{line-height:1;}
 
 /* Composer wrap: slightly less padding on smaller heights */
-.composer-wrap{border-top:1px solid rgba(255,255,255,.07);padding:10px 20px 14px;}
+.composer-wrap{border-top:1px solid rgba(255,255,255,.07);padding:10px 20px 14px;position:relative;z-index:10;}
 
 /* Cron status badges: pill shape refinement */
 .cron-status{border-radius:99px;font-size:10px;letter-spacing:.04em;}
@@ -411,9 +662,14 @@
   transition:background .15s;
 }
 .resize-handle:hover,.resize-handle.dragging{background:rgba(124,185,255,.35);}
-.sidebar{position:relative;}
+/* Desktop-only: position:relative for sidebar/rightpanel resize handles.
+   Must be scoped to min-width:641px so it doesn't override the mobile
+   position:fixed slide-in overlay set in the max-width:640px @media block above. */
+@media(min-width:641px){
+  .sidebar{position:relative;}
+  .rightpanel{position:relative;}
+}
 .sidebar .resize-handle{right:-2px;}
-.rightpanel{position:relative;}
 .rightpanel .resize-handle{left:-2px;}
 /* Prevent text selection during drag */
 body.resizing{user-select:none;cursor:col-resize;}
@@ -424,6 +680,26 @@ body.resizing{user-select:none;cursor:col-resize;}
 /* Show more button inside tool card result */
 .tool-card-more{background:none;border:none;color:var(--blue);font-size:10px;cursor:pointer;padding:3px 0 0;opacity:.7;display:block;}
 .tool-card-more:hover{opacity:1;}
+/* Subagent cards: indented with accent border */
+.tool-card-subagent{border-left:2px solid rgba(124,185,255,.3);margin-left:8px;}
+/* Token usage badge below assistant messages */
+.msg-usage{font-size:11px;color:var(--muted);opacity:.6;margin-top:2px;padding-left:42px;}
+.msg-usage:hover{opacity:1;}
+/* Skill picker (cron create form) */
+.skill-picker-wrap{position:relative;}
+.skill-picker-dropdown{position:absolute;left:0;right:0;top:100%;background:var(--sidebar);border:1px solid var(--border2);border-radius:6px;z-index:1100;max-height:180px;overflow-y:auto;box-shadow:0 4px 12px rgba(0,0,0,.3);}
+.skill-opt{padding:6px 10px;cursor:pointer;font-size:12px;color:var(--muted);transition:background .1s;}
+.skill-opt:hover{background:rgba(255,255,255,.08);color:var(--text);}
+.skill-picker-tags{display:flex;flex-wrap:wrap;gap:4px;margin-top:4px;}
+.skill-tag{background:rgba(124,185,255,.12);border:1px solid rgba(124,185,255,.25);border-radius:12px;padding:2px 8px;font-size:11px;color:var(--blue);display:flex;align-items:center;gap:4px;}
+.remove-tag{cursor:pointer;opacity:.6;font-size:13px;line-height:1;}
+.remove-tag:hover{opacity:1;color:var(--accent);}
+/* Skill linked files section */
+.skill-linked-files{margin-top:16px;border-top:1px solid var(--border);padding-top:12px;}
+.skill-linked-section{margin-bottom:8px;}
+.skill-linked-section h4{font-size:10px;text-transform:uppercase;letter-spacing:.05em;color:var(--muted);margin-bottom:4px;}
+.skill-linked-file{display:block;font-size:12px;padding:3px 6px;border-radius:4px;cursor:pointer;color:var(--blue);text-decoration:none;}
+.skill-linked-file:hover{background:var(--hover-bg);}
 .tool-card-row{margin:0;padding:1px 0;}
 .tool-card{background:rgba(255,255,255,.03);border:1px solid rgba(255,255,255,.07);border-radius:6px;margin:2px 0 2px 40px;overflow:hidden;transition:border-color .15s;}
 .tool-card:hover{border-color:rgba(255,255,255,.12);}
@@ -451,9 +727,9 @@ body.resizing{user-select:none;cursor:col-resize;}
 
 /* ── Settings overlay ── */
 .settings-overlay{position:fixed;inset:0;background:rgba(0,0,0,.5);z-index:1000;display:flex;align-items:center;justify-content:center;}
-.settings-panel{background:var(--bg);border:1px solid var(--border);border-radius:12px;padding:0;width:380px;max-width:90vw;max-height:80vh;overflow-y:auto;box-shadow:0 12px 40px rgba(0,0,0,.5);}
+.settings-panel{background:var(--bg);border:1px solid var(--border);border-radius:12px;padding:0;width:420px;max-width:92vw;max-height:92vh;min-height:min(680px,90vh);overflow:visible;box-shadow:0 12px 40px rgba(0,0,0,.5);display:flex;flex-direction:column;}
 .settings-header{display:flex;align-items:center;justify-content:space-between;padding:16px 20px 12px;border-bottom:1px solid var(--border);}
-.settings-body{padding:20px;}
+.settings-body{padding:20px;overflow-y:auto;flex:1;}
 .settings-field{margin-bottom:16px;}
 .settings-field label{display:block;font-size:11px;font-weight:600;letter-spacing:.05em;text-transform:uppercase;color:var(--muted);margin-bottom:6px;}
 /* Save button inside the settings panel */
@@ -463,15 +739,9 @@ body.resizing{user-select:none;cursor:col-resize;}
 .gear-btn{font-size:13px;cursor:pointer;transition:color .15s,background .15s;}
 .gear-btn:hover{color:var(--text);background:rgba(255,255,255,.08);}
 
-/* ── Session pin star ── */
-.session-pin{font-size:12px;cursor:pointer;opacity:0;transition:opacity .15s;padding:2px 4px;flex-shrink:0;}
-.session-item:hover .session-pin,.session-pin.pinned{opacity:1;}
-.session-pin.pinned{color:#f5c542;}
-
-/* ── Session duplicate button ── */
-.session-dup,.session-action-btn{background:none;border:none;color:var(--muted);font-size:11px;cursor:pointer;opacity:0;transition:opacity .15s;padding:2px 4px;flex-shrink:0;}
-.session-item:hover .session-dup,.session-item:hover .session-action-btn{opacity:1;}
-.session-dup:hover,.session-action-btn:hover{color:var(--text);}
+/* ── Session pin indicator (inline, only when pinned) ── */
+.session-pin-indicator{flex-shrink:0;color:#f5c542;line-height:1;display:flex;align-items:center;}
+.session-pin-indicator svg{width:10px;height:10px;}
 
 /* ── Cron alert badge ── */
 .cron-badge{position:absolute;top:2px;right:2px;background:#e53e3e;color:#fff;font-size:9px;font-weight:700;min-width:14px;height:14px;line-height:14px;text-align:center;border-radius:7px;padding:0 3px;}
@@ -497,4 +767,63 @@ body.resizing{user-select:none;cursor:col-resize;}
 .mermaid-rendered{background:transparent;padding:8px 0;}
 .mermaid-rendered svg{max-width:100%;height:auto;}
 
+/* ── Session projects ── */
+.project-bar{display:flex;gap:4px;padding:4px 10px 8px;flex-wrap:wrap;align-items:center;flex-shrink:0;}
+.project-chip{font-size:10px;font-weight:600;padding:3px 8px;border-radius:12px;cursor:pointer;border:1px solid var(--border2);background:var(--input-bg);color:var(--muted);transition:all .15s;white-space:nowrap;display:inline-flex;align-items:center;gap:4px;}
+.project-chip:hover{background:rgba(255,255,255,.08);color:var(--text);}
+.project-chip.active{background:rgba(124,185,255,.12);color:var(--blue);border-color:rgba(124,185,255,.4);}
+.project-chip .color-dot{width:6px;height:6px;border-radius:50%;display:inline-block;flex-shrink:0;}
+.project-create-btn{font-size:10px;padding:3px 6px;border-radius:12px;cursor:pointer;border:1px dashed var(--border2);background:none;color:var(--muted);opacity:.6;transition:all .15s;}
+.project-create-btn:hover{opacity:1;border-color:var(--blue);color:var(--blue);}
+.project-create-input{font-size:10px;padding:3px 8px;border-radius:12px;border:1px solid rgba(124,185,255,.6);background:var(--surface);color:var(--text);outline:none;width:100px;font-family:inherit;box-shadow:0 0 0 2px rgba(124,185,255,.15);}
+.project-picker{position:absolute;right:0;top:100%;background:var(--sidebar);border:1px solid var(--border2);border-radius:8px;padding:4px;z-index:30;min-width:160px;max-width:220px;width:max-content;box-shadow:0 4px 16px rgba(0,0,0,.3);}
+.project-picker-item{padding:5px 10px;font-size:11px;border-radius:6px;cursor:pointer;color:var(--muted);transition:all .1s;display:flex;align-items:center;gap:6px;}
+.project-picker-item:hover{background:rgba(255,255,255,.08);color:var(--text);}
+.project-picker-item.active{color:var(--blue);}
+.project-picker-create{color:var(--blue);opacity:.7;border-top:1px solid var(--border2);margin-top:2px;padding-top:6px;}
+.project-picker-create:hover{opacity:1;background:rgba(124,185,255,.08);}
+.session-project-dot{width:6px;height:6px;border-radius:50%;flex-shrink:0;display:inline-block;margin-left:4px;vertical-align:middle;}
+
+/* ── Code copy button ── */
+.code-copy-btn{background:var(--hover-bg);border:1px solid var(--border2);border-radius:4px;color:var(--muted);font-size:11px;cursor:pointer;padding:2px 6px;transition:all .15s;line-height:1.3;}
+.code-copy-btn:hover{background:rgba(255,255,255,.12);color:var(--text);}
+
+/* ── Tool card expand/collapse toggle ── */
+.tool-cards-toggle{margin:4px 0 2px 40px;display:flex;gap:8px;}
+.tool-cards-toggle button{background:none;border:none;color:var(--blue);font-size:10px;cursor:pointer;opacity:.6;padding:0;}
+.tool-cards-toggle button:hover{opacity:1;text-decoration:underline;}
+
+/* ── Thinking/reasoning card ── */
+.thinking-card{background:rgba(201,168,76,.06);border:1px solid rgba(201,168,76,.2);border-radius:10px;margin:4px 0 2px 40px;overflow:hidden;transition:border-color .15s;}
+.thinking-card:hover{border-color:rgba(201,168,76,.35);}
+.thinking-card-header{display:flex;align-items:center;gap:6px;padding:6px 12px;cursor:pointer;font-size:12px;color:var(--gold);user-select:none;}
+.thinking-card-icon{font-size:14px;}
+.thinking-card-label{font-weight:600;letter-spacing:.02em;}
+.thinking-card-toggle{margin-left:auto;font-size:10px;transition:transform .15s;}
+.thinking-card.open .thinking-card-toggle{transform:rotate(90deg);}
+.thinking-card-body{display:none;padding:0 12px 10px;max-height:300px;overflow-y:auto;}
+.thinking-card.open .thinking-card-body{display:block;}
+.thinking-card-body pre{font-family:'SF Mono',ui-monospace,monospace;font-size:11px;line-height:1.5;color:var(--muted);white-space:pre-wrap;word-break:break-word;margin:0;}
+
 .bg-error-banner{background:rgba(229,62,62,.15);border:1px solid rgba(229,62,62,.3);color:#fca5a5;padding:8px 16px;font-size:12px;display:flex;align-items:center;justify-content:space-between;gap:12px;border-radius:0;}
+
+/* ── CLI session items in sidebar ── */
+.session-item.cli-session {
+  border-left-color: var(--gold);
+  padding-right: 36px; /* make room for session-actions overlay */
+}
+.session-item.cli-session::after {
+  content: 'cli';
+  font-size: 9px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: .04em;
+  color: var(--gold);
+  opacity: .5;
+  margin-left: auto;
+  flex-shrink: 0;
+  pointer-events: none; /* don't block clicks on session-actions beneath */
+}
+.session-item.cli-session:hover::after {
+  display: none; /* hide badge on hover so session-actions icons are fully reachable */
+}

static/ui.js

@@ -1,4 +1,4 @@
-const S={session:null,messages:[],entries:[],busy:false,pendingFiles:[],toolCalls:[],activeStreamId:null};
+const S={session:null,messages:[],entries:[],busy:false,pendingFiles:[],toolCalls:[],activeStreamId:null,currentDir:'.',activeProfile:'default'};
 const INFLIGHT={};  // keyed by session_id while request in-flight
 const MSG_QUEUE=[];  // messages queued while a request is in-flight
 const $=id=>document.getElementById(id);
@@ -7,11 +7,43 @@ const esc=s=>String(s??'').replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&
 // Dynamic model labels -- populated by populateModelDropdown(), fallback to static map
 let _dynamicModelLabels={};
 
+// ── Smart model resolver ────────────────────────────────────────────────────
+// Finds the best matching option value in a <select> for a given model ID.
+// Handles mismatches like 'claude-sonnet-4-6' vs 'anthropic/claude-sonnet-4.6'.
+// Returns the matched option's value (already in the list), or null if no match.
+function _findModelInDropdown(modelId, sel){
+  if(!modelId||!sel) return null;
+  const opts=Array.from(sel.options).map(o=>o.value);
+  // 1. Exact match
+  if(opts.includes(modelId)) return modelId;
+  // 2. Normalize: lowercase, strip namespace prefix, replace hyphens→dots
+  const norm=s=>s.toLowerCase().replace(/^[^/]+\//,'').replace(/-/g,'.');
+  const target=norm(modelId);
+  const exact=opts.find(o=>norm(o)===target);
+  if(exact) return exact;
+  // 3. Prefix/substring: target starts with or contains a significant chunk
+  const base=target.replace(/\.\d+$/,'');  // strip trailing version number
+  const partial=opts.find(o=>norm(o).startsWith(base)||norm(o).includes(base));
+  return partial||null;
+}
+
+// Set the model picker to the best match for modelId.
+// Returns the resolved value that was actually set, or null if nothing matched.
+function _applyModelToDropdown(modelId, sel){
+  if(!modelId||!sel) return null;
+  const resolved=_findModelInDropdown(modelId,sel);
+  if(resolved){
+    sel.value=resolved;
+    return resolved;
+  }
+  return null;
+}
+
 async function populateModelDropdown(){
   const sel=$('modelSelect');
   if(!sel) return;
   try{
-    const data=await fetch('/api/models').then(r=>r.json());
+    const data=await fetch(new URL('/api/models',location.origin).href,{credentials:'include'}).then(r=>r.json());
     if(!data.groups||!data.groups.length) return; // keep HTML defaults
     // Clear existing options
     sel.innerHTML='';
@@ -30,15 +62,7 @@ async function populateModelDropdown(){
     }
     // Set default model from server if no localStorage preference
     if(data.default_model && !localStorage.getItem('hermes-webui-model')){
-      sel.value=data.default_model;
-      // If the default isn't in the list, add it
-      if(sel.value!==data.default_model){
-        const opt=document.createElement('option');
-        opt.value=data.default_model;
-        opt.textContent=data.default_model.split('/').pop();
-        sel.insertBefore(opt,sel.firstChild);
-        sel.value=data.default_model;
-      }
+      _applyModelToDropdown(data.default_model, sel);
     }
   }catch(e){
     // API unavailable -- keep the hardcoded HTML options as fallback
@@ -58,6 +82,36 @@ let _scrollPinned=true;
     _scrollPinned=nearBottom;
   });
 })();
+function _fmtTokens(n){if(!n||n<0)return'0';if(n>=1e6)return(n/1e6).toFixed(1)+'M';if(n>=1e3)return(n/1e3).toFixed(1)+'k';return String(n);}
+
+// Context usage indicator in composer footer
+function _syncCtxIndicator(usage){
+  const el=$('ctxIndicator');
+  if(!el)return;
+  const promptTok=usage.last_prompt_tokens||usage.input_tokens||0;
+  const ctxWindow=usage.context_length||0;
+  if(!promptTok||!ctxWindow){el.style.display='none';return;}
+  el.style.display='';
+  const pct=Math.min(100,Math.round((promptTok/ctxWindow)*100));
+  const bar=$('ctxBar');
+  const label=$('ctxLabel');
+  if(bar){
+    bar.style.width=pct+'%';
+    bar.className='ctx-bar'+(pct>75?' ctx-high':pct>50?' ctx-mid':'');
+  }
+  if(label){
+    const cost=usage.estimated_cost;
+    let text=`${_fmtTokens(promptTok)} / ${_fmtTokens(ctxWindow)}`;
+    if(pct>0) text+=` (${pct}%)`;
+    if(cost) text+=` \u00b7 $${cost<0.01?cost.toFixed(4):cost.toFixed(2)}`;
+    label.textContent=text;
+  }
+  // Update title with detailed info
+  const threshold=usage.threshold_tokens||0;
+  el.title=`Context: ${_fmtTokens(promptTok)} of ${_fmtTokens(ctxWindow)} tokens used`
+    +(threshold?`\nAuto-compress at ${_fmtTokens(threshold)} (${Math.round(threshold/ctxWindow*100)}%)`:'');
+}
+
 function scrollIfPinned(){
   if(!_scrollPinned) return;
   const el=$('messages');
@@ -81,6 +135,22 @@ function getModelLabel(modelId){
 
 function renderMd(raw){
   let s=raw||'';
+  // Pre-pass: convert safe inline HTML tags the model may emit into their
+  // markdown equivalents so the pipeline can render them correctly.
+  // Only runs OUTSIDE fenced code blocks and backtick spans (stash + restore).
+  // Unsafe tags (anything not in the allowlist) are left as-is and will be
+  // HTML-escaped by esc() when they reach an innerHTML assignment -- no XSS risk.
+  const fence_stash=[];
+  s=s.replace(/(```[\s\S]*?```|`[^`\n]+`)/g,m=>{fence_stash.push(m);return '\x00F'+(fence_stash.length-1)+'\x00';});
+  // Safe tag → markdown equivalent (these produce the same output as **text** etc.)
+  s=s.replace(/<strong>([\s\S]*?)<\/strong>/gi,(_,t)=>'**'+t+'**');
+  s=s.replace(/<b>([\s\S]*?)<\/b>/gi,(_,t)=>'**'+t+'**');
+  s=s.replace(/<em>([\s\S]*?)<\/em>/gi,(_,t)=>'*'+t+'*');
+  s=s.replace(/<i>([\s\S]*?)<\/i>/gi,(_,t)=>'*'+t+'*');
+  s=s.replace(/<code>([^<]*?)<\/code>/gi,(_,t)=>'`'+t+'`');
+  s=s.replace(/<br\s*\/?>/gi,'\n');
+  // Restore stashed code blocks
+  s=s.replace(/\x00F(\d+)\x00/g,(_,i)=>fence_stash[+i]);
   // Mermaid blocks: render as diagram containers (processed after DOM insertion)
   s=s.replace(/```mermaid\n?([\s\S]*?)```/g,(_,code)=>{
     const id='mermaid-'+Math.random().toString(36).slice(2,10);
@@ -88,12 +158,27 @@ function renderMd(raw){
   });
   s=s.replace(/```([\w+-]*)\n?([\s\S]*?)```/g,(_,lang,code)=>{const h=lang?`<div class="pre-header">${esc(lang)}</div>`:'';return `${h}<pre><code>${esc(code.replace(/\n$/,''))}</code></pre>`;});
   s=s.replace(/`([^`\n]+)`/g,(_,c)=>`<code>${esc(c)}</code>`);
-  s=s.replace(/\*\*\*(.+?)\*\*\*/g,'<strong><em>$1</em></strong>');
-  s=s.replace(/\*\*(.+?)\*\*/g,'<strong>$1</strong>');
-  s=s.replace(/\*([^*\n]+)\*/g,'<em>$1</em>');
-  s=s.replace(/^### (.+)$/gm,'<h3>$1</h3>').replace(/^## (.+)$/gm,'<h2>$1</h2>').replace(/^# (.+)$/gm,'<h1>$1</h1>');
+  // inlineMd: process bold/italic/code/links within a single line of text.
+  // Used inside list items and blockquotes where the text may already contain
+  // HTML from the pre-pass → bold pipeline, so we cannot call esc() directly.
+  function inlineMd(t){
+    t=t.replace(/\*\*\*(.+?)\*\*\*/g,(_,x)=>`<strong><em>${esc(x)}</em></strong>`);
+    t=t.replace(/\*\*(.+?)\*\*/g,(_,x)=>`<strong>${esc(x)}</strong>`);
+    t=t.replace(/\*([^*\n]+)\*/g,(_,x)=>`<em>${esc(x)}</em>`);
+    t=t.replace(/`([^`\n]+)`/g,(_,x)=>`<code>${esc(x)}</code>`);
+    t=t.replace(/\[([^\]]+)\]\((https?:\/\/[^\)]+)\)/g,(_,lb,u)=>`<a href="${esc(u)}" target="_blank" rel="noopener">${esc(lb)}</a>`);
+    // Escape any plain text that isn't already wrapped in a tag we produced
+    // by escaping bare < > that aren't part of our own tags
+    const SAFE_INLINE=/^<\/?(strong|em|code|a)([\s>]|$)/i;
+    t=t.replace(/<\/?[a-z][^>]*>/gi,tag=>SAFE_INLINE.test(tag)?tag:esc(tag));
+    return t;
+  }
+  s=s.replace(/\*\*\*(.+?)\*\*\*/g,(_,t)=>`<strong><em>${esc(t)}</em></strong>`);
+  s=s.replace(/\*\*(.+?)\*\*/g,(_,t)=>`<strong>${esc(t)}</strong>`);
+  s=s.replace(/\*([^*\n]+)\*/g,(_,t)=>`<em>${esc(t)}</em>`);
+  s=s.replace(/^### (.+)$/gm,(_,t)=>`<h3>${inlineMd(t)}</h3>`).replace(/^## (.+)$/gm,(_,t)=>`<h2>${inlineMd(t)}</h2>`).replace(/^# (.+)$/gm,(_,t)=>`<h1>${inlineMd(t)}</h1>`);
   s=s.replace(/^---+$/gm,'<hr>');
-  s=s.replace(/^> (.+)$/gm,'<blockquote>$1</blockquote>');
+  s=s.replace(/^> (.+)$/gm,(_,t)=>`<blockquote>${inlineMd(t)}</blockquote>`);
   // B8: improved list handling supporting up to 2 levels of indentation
   s=s.replace(/((?:^(?:  )?[-*+] .+\n?)+)/gm,block=>{
     const lines=block.trimEnd().split('\n');
@@ -101,8 +186,8 @@ function renderMd(raw){
     for(const l of lines){
       const indent=/^ {2,}/.test(l);
       const text=l.replace(/^ {0,4}[-*+] /,'');
-      if(indent) html+=`<li style="margin-left:16px">${text}</li>`;
-      else html+=`<li>${text}</li>`;
+      if(indent) html+=`<li style="margin-left:16px">${inlineMd(text)}</li>`;
+      else html+=`<li>${inlineMd(text)}</li>`;
     }
     return html+'</ul>';
   });
@@ -111,23 +196,29 @@ function renderMd(raw){
     let html='<ol>';
     for(const l of lines){
       const text=l.replace(/^ {0,4}\d+\. /,'');
-      html+=`<li>${text}</li>`;
+      html+=`<li>${inlineMd(text)}</li>`;
     }
     return html+'</ol>';
   });
-  s=s.replace(/\[([^\]]+)\]\((https?:\/\/[^\)]+)\)/g,'<a href="$2" target="_blank" rel="noopener">$1</a>');
+  s=s.replace(/\[([^\]]+)\]\((https?:\/\/[^\)]+)\)/g,(_,label,url)=>`<a href="${esc(url)}" target="_blank" rel="noopener">${esc(label)}</a>`);
   // Tables: | col | col | header row followed by | --- | --- | separator then data rows
   s=s.replace(/((?:^\|.+\|\n?)+)/gm,block=>{
     const rows=block.trim().split('\n').filter(r=>r.trim());
     if(rows.length<2)return block;
     const isSep=r=>/^\|[\s|:-]+\|$/.test(r.trim());
     if(!isSep(rows[1]))return block;
-    const parseRow=r=>r.trim().replace(/^\|/,'').replace(/\|$/,'').split('|').map(c=>`<td>${c.trim()}</td>`).join('');
-    const parseHeader=r=>r.trim().replace(/^\|/,'').replace(/\|$/,'').split('|').map(c=>`<th>${c.trim()}</th>`).join('');
+    const parseRow=r=>r.trim().replace(/^\|/,'').replace(/\|$/,'').split('|').map(c=>`<td>${esc(c.trim())}</td>`).join('');
+    const parseHeader=r=>r.trim().replace(/^\|/,'').replace(/\|$/,'').split('|').map(c=>`<th>${esc(c.trim())}</th>`).join('');
     const header=`<tr>${parseHeader(rows[0])}</tr>`;
     const body=rows.slice(2).map(r=>`<tr>${parseRow(r)}</tr>`).join('');
     return `<table><thead>${header}</thead><tbody>${body}</tbody></table>`;
   });
+  // Escape any remaining HTML tags that are NOT from our own markdown output.
+  // Our pipeline only emits: <strong>,<em>,<code>,<pre>,<h1-6>,<ul>,<ol>,<li>,
+  // <table>,<thead>,<tbody>,<tr>,<th>,<td>,<hr>,<blockquote>,<p>,<br>,<a>,
+  // <div class="..."> (mermaid/pre-header). Everything else is untrusted input.
+  const SAFE_TAGS=/^<\/?(strong|em|code|pre|h[1-6]|ul|ol|li|table|thead|tbody|tr|th|td|hr|blockquote|p|br|a|div)([\s>]|$)/i;
+  s=s.replace(/<\/?[a-z][^>]*>/gi,tag=>SAFE_TAGS.test(tag)?tag:esc(tag));
   const parts=s.split(/\n{2,}/);
   s=parts.map(p=>{p=p.trim();if(!p)return '';if(/^<(h[1-6]|ul|ol|pre|hr|blockquote)/.test(p))return p;return `<p>${p.replace(/\n/g,'<br>')}</p>`;}).join('\n');
   return s;
@@ -146,13 +237,29 @@ function setStatus(t){
     txt.textContent=t;
     bar.style.display='';
     // Show dismiss X only for static/error messages, not transient busy ones
-    const transient = t.endsWith('…') || t === 'Hermes is thinking…';
+    const transient = t.endsWith('…') || t === (window._botName||'Hermes')+' is thinking\u2026';
     if(dismiss)dismiss.style.display=(!transient && !S.busy)?'inline':'none';
   }
 }
+function updateSendBtn(){
+  const btn=$('btnSend');
+  if(!btn) return;
+  const hasContent=$('msg').value.trim().length>0||S.pendingFiles.length>0;
+  const shouldShow=hasContent&&!S.busy;
+  if(shouldShow&&btn.style.display==='none'){
+    btn.style.display='';
+    // Remove then re-add class to retrigger animation each time
+    btn.classList.remove('visible');
+    requestAnimationFrame(()=>btn.classList.add('visible'));
+  } else if(!shouldShow&&btn.style.display!=='none'){
+    btn.style.display='none';
+    btn.classList.remove('visible');
+  }
+}
 function setBusy(v){
   S.busy=v;
   $('btnSend').disabled=v;
+  updateSendBtn();
   const dots=$('activityDots');
   if(dots) dots.style.display=v?'flex':'none';
   if(!v){
@@ -227,6 +334,47 @@ async function refreshSession() {
     showToast('Conversation refreshed');
   } catch(e) { setStatus('Refresh failed: ' + e.message); }
 }
+// ── Update banner ──
+function _showUpdateBanner(data){
+  const parts=[];
+  if(data.webui&&data.webui.behind>0) parts.push(`WebUI: ${data.webui.behind} update${data.webui.behind>1?'s':''}`);
+  if(data.agent&&data.agent.behind>0) parts.push(`Agent: ${data.agent.behind} update${data.agent.behind>1?'s':''}`);
+  if(!parts.length)return;
+  const msg=$('updateMsg');
+  if(msg) msg.textContent='\u2B06 '+parts.join(', ')+' available';
+  const banner=$('updateBanner');
+  if(banner) banner.classList.add('visible');
+  window._updateData=data;
+}
+function dismissUpdate(){
+  const b=$('updateBanner');if(b)b.classList.remove('visible');
+  sessionStorage.setItem('hermes-update-dismissed','1');
+}
+async function applyUpdates(){
+  const btn=$('btnApplyUpdate');
+  if(btn){btn.disabled=true;btn.textContent='Updating\u2026';}
+  const targets=[];
+  if(window._updateData?.webui?.behind>0) targets.push('webui');
+  if(window._updateData?.agent?.behind>0) targets.push('agent');
+  try{
+    for(const target of targets){
+      const res=await api('/api/updates/apply',{method:'POST',body:JSON.stringify({target})});
+      if(!res.ok){
+        showToast('Update failed ('+target+'): '+(res.message||'unknown error'));
+        if(btn){btn.disabled=false;btn.textContent='Update Now';}
+        return;
+      }
+    }
+    showToast('Updated! Reloading\u2026');
+    sessionStorage.removeItem('hermes-update-checked');
+    sessionStorage.removeItem('hermes-update-dismissed');
+    setTimeout(()=>location.reload(),1500);
+  }catch(e){
+    showToast('Update failed: '+e.message);
+    if(btn){btn.disabled=false;btn.textContent='Update Now';}
+  }
+}
+
 async function checkInflightOnBoot(sid) {
   const raw = localStorage.getItem(INFLIGHT_KEY);
   if (!raw) return;
@@ -254,7 +402,7 @@ async function checkInflightOnBoot(sid) {
 
 function syncTopbar(){
   if(!S.session){
-    document.title='Hermes';
+    document.title=window._botName||'Hermes';
     // Show default workspace name even without a session
     const sidebarName=$('sidebarWsName');
     if(sidebarName && sidebarName.textContent==='Workspace'){
@@ -264,18 +412,31 @@ function syncTopbar(){
   }
   const sessionTitle=S.session.title||'Untitled';
   $('topbarTitle').textContent=sessionTitle;
-  document.title=sessionTitle+' \u2014 Hermes';
+  document.title=sessionTitle+' \u2014 '+(window._botName||'Hermes');
   const vis=S.messages.filter(m=>m&&m.role&&m.role!=='tool');
   $('topbarMeta').textContent=`${vis.length} messages`;
-  const m=S.session.model||'';
-  $('modelSelect').value=m;  // set dropdown first so chip reads consistent value
-  // If session model isn't in the dropdown, add it dynamically
-  if(m && $('modelSelect').value!==m){
-    const opt=document.createElement('option');
-    opt.value=m;
-    opt.textContent=getModelLabel(m);
-    $('modelSelect').appendChild(opt);
-    $('modelSelect').value=m;
+  // If a profile switch just happened, apply its model rather than the session's stale value.
+  // S._pendingProfileModel is set by switchToProfile() and cleared here after one application.
+  const modelOverride=S._pendingProfileModel;
+  if(modelOverride){
+    S._pendingProfileModel=null;
+    _applyModelToDropdown(modelOverride,$('modelSelect'));
+  } else {
+    const m=S.session.model||'';
+    const applied=_applyModelToDropdown(m,$('modelSelect'));
+    // If the model isn't in the current provider list, add it as a visually marked
+    // "(unavailable)" entry so the session value is preserved without misleading the user.
+    // Selecting it will still attempt to send (same as before), but the label makes
+    // clear it's a stale model from a previous session.
+    if(!applied && m){
+      const opt=document.createElement('option');
+      opt.value=m;
+      opt.textContent=getModelLabel(m)+' (unavailable)';
+      opt.style.color='var(--muted, #888)';
+      opt.title='This model is no longer in your current provider list';
+      $('modelSelect').appendChild(opt);
+      $('modelSelect').value=m;
+    }
   }
   // Show Clear button only when session has messages
   const clearBtn=$('btnClearConv');
@@ -283,13 +444,6 @@ function syncTopbar(){
   const displayModel=$('modelSelect').value||m;
   $('modelChip').textContent=getModelLabel(displayModel);
   const ws=S.session.workspace||'';
-  $('wsChip').textContent=ws.split('/').slice(-2).join('/')||ws;
-  // Update workspace chip in topbar with friendly name from workspace list
-  const wsChipEl=$('wsChip');
-  if(wsChipEl){
-    const wsFriendly=getWorkspaceFriendlyName(ws);
-    wsChipEl.textContent='\u{1F4C1} '+wsFriendly+' \u25BE';
-  }
   // Update sidebar workspace display
   const sidebarName=$('sidebarWsName');
   const sidebarPath=$('sidebarWsPath');
@@ -300,6 +454,9 @@ function syncTopbar(){
     sidebarPath.textContent=ws;
   }
   // modelSelect already set above
+  // Update profile chip label
+  const profileLabel=$('profileChipLabel');
+  if(profileLabel) profileLabel.textContent=S.activeProfile||'default';
 }
 
 function msgContent(m){
@@ -313,26 +470,45 @@ function renderMessages(){
   const inner=$('msgInner');
   const vis=S.messages.filter(m=>{
     if(!m||!m.role||m.role==='tool')return false;
+    // Keep assistant messages with tool_use content even if they have no text,
+    // so tool cards can be anchored to their DOM rows on page reload (#140).
+    if(m.role==='assistant'&&Array.isArray(m.content)&&m.content.some(p=>p&&p.type==='tool_use'))return true;
     return msgContent(m)||m.attachments?.length;
   });
   $('emptyState').style.display=vis.length?'none':'';
   inner.innerHTML='';
-  // Track original indices (in S.messages) so truncate knows the cut point
+  // Track original indices (in S.messages) so truncate knows the cut point.
+  // Also include assistant messages that have tool_calls (OpenAI format) or
+  // tool_use content (Anthropic format) even when their text is empty — these
+  // rows serve as DOM anchors for tool card insertion on page reload.
   const visWithIdx=[];
   let rawIdx=0;
   for(const m of S.messages){
     if(!m||!m.role||m.role==='tool'){rawIdx++;continue;}
-    if(msgContent(m)||m.attachments?.length) visWithIdx.push({m,rawIdx});
+    const hasTc=Array.isArray(m.tool_calls)&&m.tool_calls.length>0;
+    const hasTu=Array.isArray(m.content)&&m.content.some(p=>p&&p.type==='tool_use');
+    if(msgContent(m)||m.attachments?.length||(m.role==='assistant'&&(hasTc||hasTu))) visWithIdx.push({m,rawIdx});
     rawIdx++;
   }
   for(let vi=0;vi<visWithIdx.length;vi++){
     const {m,rawIdx}=visWithIdx[vi];
     let content=m.content||'';
-    if(Array.isArray(content))content=content.filter(p=>p&&p.type==='text').map(p=>p.text||p.content||'').join('\n');
+    // Extract thinking/reasoning blocks from structured content (Claude extended thinking, o3)
+    let thinkingText='';
+    if(Array.isArray(content)){
+      thinkingText=content.filter(p=>p&&(p.type==='thinking'||p.type==='reasoning')).map(p=>p.thinking||p.reasoning||p.text||'').join('\n');
+      content=content.filter(p=>p&&p.type==='text').map(p=>p.text||p.content||'').join('\n');
+    }
     const isUser=m.role==='user';
     const isLastAssistant=!isUser&&vi===visWithIdx.length-1;
+    // Render thinking card before the assistant message (collapsed by default)
+    if(thinkingText&&!isUser){
+      const thinkRow=document.createElement('div');thinkRow.className='msg-row thinking-card-row';
+      thinkRow.innerHTML=`<div class="thinking-card"><div class="thinking-card-header" onclick="this.parentElement.classList.toggle('open')"><span class="thinking-card-icon">&#128161;</span><span class="thinking-card-label">Thinking</span><span class="thinking-card-toggle">&#9656;</span></div><div class="thinking-card-body"><pre>${esc(thinkingText)}</pre></div></div>`;
+      inner.appendChild(thinkRow);
+    }
     const row=document.createElement('div');row.className='msg-row';
-    row.dataset.msgIdx=rawIdx;
+    row.dataset.msgIdx=rawIdx;row.dataset.role=m.role||'assistant';
     let filesHtml='';
     if(m.attachments&&m.attachments.length)
       filesHtml=`<div class="msg-files">${m.attachments.map(f=>`<div class="msg-file-badge">&#128206; ${esc(f)}</div>`).join('')}</div>`;
@@ -342,13 +518,36 @@ function renderMessages(){
     const retryBtn = isLastAssistant ? `<button class="msg-action-btn" title="Regenerate response" onclick="regenerateResponse(this)">&#8635;</button>` : '';
     const tsVal=m._ts||m.timestamp;
     const tsTitle=tsVal?new Date(tsVal*1000).toLocaleString():'';
-    row.innerHTML=`<div class="msg-role ${m.role}" ${tsTitle?`title="${esc(tsTitle)}"`:''}><div class="role-icon ${m.role}">${isUser?'Y':'H'}</div><span style="font-size:12px">${isUser?'You':'Hermes'}</span>${tsTitle?`<span class="msg-time">${new Date(tsVal*1000).toLocaleTimeString([],{hour:'2-digit',minute:'2-digit'})}</span>`:''}<span class="msg-actions">${editBtn}<button class="msg-copy-btn msg-action-btn" title="Copy" onclick="copyMsg(this)">&#128203;</button>${retryBtn}</span></div>${filesHtml}<div class="msg-body">${bodyHtml}</div>`;
+    const _bn=window._botName||'Hermes';
+    row.innerHTML=`<div class="msg-role ${m.role}" ${tsTitle?`title="${esc(tsTitle)}"`:''}><div class="role-icon ${m.role}">${isUser?'Y':esc(_bn.charAt(0).toUpperCase())}</div><span style="font-size:12px">${isUser?'You':esc(_bn)}</span>${tsTitle?`<span class="msg-time">${new Date(tsVal*1000).toLocaleTimeString([],{hour:'2-digit',minute:'2-digit'})}</span>`:''}<span class="msg-actions">${editBtn}<button class="msg-copy-btn msg-action-btn" title="Copy" onclick="copyMsg(this)">&#128203;</button>${retryBtn}</span></div>${filesHtml}<div class="msg-body">${bodyHtml}</div>`;
     row.dataset.rawText = String(content).trim();
     inner.appendChild(row);
   }
   // Insert settled tool call cards (history view only).
   // During live streaming, tool cards are rendered in #liveToolCards by the
   // tool SSE handler and never mixed into the message list until done fires.
+  //
+  // Fallback: if S.toolCalls is empty (sessions that predate session-level tool
+  // tracking, or runs that didn't go through the normal streaming path), build
+  // a display list from per-message tool_calls (OpenAI format) stored in each
+  // assistant message. This covers the reload case described in issue #140.
+  if(!S.busy && (!S.toolCalls||!S.toolCalls.length)){
+    const derived=[];
+    S.messages.forEach((m,rawIdx)=>{
+      if(m.role!=='assistant') return;
+      (m.tool_calls||[]).forEach(tc=>{
+        if(!tc||typeof tc!=='object') return;
+        const fn=tc.function||{};
+        const name=fn.name||tc.name||'tool';
+        let args={};
+        try{ args=JSON.parse(fn.arguments||'{}'); }catch(e){}
+        let argsSnap={};
+        Object.keys(args).slice(0,4).forEach(k=>{ const v=String(args[k]); argsSnap[k]=v.slice(0,120)+(v.length>120?'...':''); });
+        derived.push({name,snippet:'',tid:tc.id||tc.call_id||'',assistant_msg_idx:rawIdx,args:argsSnap,done:true});
+      });
+    });
+    if(derived.length) S.toolCalls=derived;
+  }
   if(!S.busy && S.toolCalls && S.toolCalls.length){
     inner.querySelectorAll('.tool-card-row').forEach(el=>el.remove());
     const byAssistant = {};
@@ -358,29 +557,86 @@ function renderMessages(){
       byAssistant[key].push(tc);
     }
     const allRows = Array.from(inner.querySelectorAll('.msg-row[data-msg-idx]'));
+    // Track the last inserted node per anchor so back-to-back groups for the
+    // same (filtered) anchor row are inserted in chronological order.
+    const anchorInsertAfter = new Map();
     for(const [key, cards] of Object.entries(byAssistant)){
       const aIdx = parseInt(key);
-      let insertBefore = null;
-      if(aIdx === -1){
-        for(let i=allRows.length-1;i>=0;i--){
-          const ri=parseInt(allRows[i].dataset.msgIdx||'-1',10);
-          if(ri>=0&&S.messages[ri]&&S.messages[ri].role==='assistant'){insertBefore=allRows[i];break;}
-        }
-      } else {
+      // Find the right insertion point: cards go AFTER the assistant message
+      // that triggered them. We look for the row at aIdx, or the nearest
+      // visible ASSISTANT row at or before aIdx (the assistant message may be
+      // filtered out if it contained only tool_use blocks with no text response).
+      let anchorRow = null;
+      if(aIdx >= 0){
+        // First: exact match for the assistant row
         for(const r of allRows){
           const ri=parseInt(r.dataset.msgIdx||'-1');
-          if(ri>aIdx&&S.messages[ri]&&S.messages[ri].role==='assistant'){insertBefore=r;break;}
+          if(ri===aIdx){anchorRow=r;break;}
+        }
+        // Fallback: nearest visible ASSISTANT row at or before aIdx
+        if(!anchorRow){
+          for(let i=allRows.length-1;i>=0;i--){
+            const ri=parseInt(allRows[i].dataset.msgIdx||'-1');
+            if(ri<=aIdx&&S.messages[ri]&&S.messages[ri].role==='assistant'){anchorRow=allRows[i];break;}
+          }
+        }
+      }
+      // aIdx === -1 or no assistant anchor found: attach after the last assistant row
+      if(!anchorRow){
+        for(let i=allRows.length-1;i>=0;i--){
+          const ri=parseInt(allRows[i].dataset.msgIdx||'-1',10);
+          if(ri>=0&&S.messages[ri]&&S.messages[ri].role==='assistant'){anchorRow=allRows[i];break;}
         }
       }
       const frag=document.createDocumentFragment();
       for(const tc of cards){frag.appendChild(buildToolCard(tc));}
-      if(insertBefore) inner.insertBefore(frag,insertBefore);
+      // Add expand/collapse toggle for groups with 2+ cards
+      if(cards.length>=2){
+        const toggle=document.createElement('div');
+        toggle.className='tool-cards-toggle';
+        // Collect card elements before they get moved to DOM
+        const cardEls=Array.from(frag.querySelectorAll('.tool-card'));
+        const expandBtn=document.createElement('button');
+        expandBtn.textContent='Expand all';
+        expandBtn.onclick=()=>cardEls.forEach(c=>c.classList.add('open'));
+        const collapseBtn=document.createElement('button');
+        collapseBtn.textContent='Collapse all';
+        collapseBtn.onclick=()=>cardEls.forEach(c=>c.classList.remove('open'));
+        toggle.appendChild(expandBtn);
+        toggle.appendChild(collapseBtn);
+        frag.insertBefore(toggle,frag.firstChild);
+      }
+      // Insert after the anchor row (or after any previously inserted group for
+      // the same anchor), preserving chronological order for multi-step chains.
+      const insertAfterNode = anchorInsertAfter.get(anchorRow) || anchorRow;
+      const refNode = insertAfterNode ? insertAfterNode.nextSibling : null;
+      if(refNode) inner.insertBefore(frag,refNode);
       else inner.appendChild(frag);
+      // Record the last child we inserted so the next group for this anchor
+      // goes after it rather than back at anchorRow.nextSibling.
+      anchorInsertAfter.set(anchorRow, inner.lastChild);
+    }
+  }
+  // Render usage badge on the last assistant message row (if enabled and usage data exists)
+  if(window._showTokenUsage&&S.session&&(S.session.input_tokens||S.session.output_tokens)){
+    const rows=inner.querySelectorAll('.msg-row');
+    let lastAssist=null;
+    for(let i=rows.length-1;i>=0;i--){if(rows[i].dataset.role==='assistant'){lastAssist=rows[i];break;}}
+    if(lastAssist&&!lastAssist.querySelector('.msg-usage')){
+      const usage=document.createElement('div');
+      usage.className='msg-usage';
+      const inTok=S.session.input_tokens||0;
+      const outTok=S.session.output_tokens||0;
+      const cost=S.session.estimated_cost;
+      let text=`${_fmtTokens(inTok)} in · ${_fmtTokens(outTok)} out`;
+      if(cost) text+=` · ~$${cost<0.01?cost.toFixed(4):cost.toFixed(2)}`;
+      usage.textContent=text;
+      lastAssist.appendChild(usage);
     }
   }
   scrollToBottom();
   // Apply syntax highlighting after DOM is built
-  requestAnimationFrame(()=>{highlightCode();renderMermaidBlocks();});
+  requestAnimationFrame(()=>{highlightCode();addCopyButtons();renderMermaidBlocks();});
   // Refresh todo panel if it's currently open
   if(typeof loadTodos==='function' && document.getElementById('panelTodos') && document.getElementById('panelTodos').classList.contains('active')){
     loadTodos();
@@ -391,7 +647,8 @@ function toolIcon(name){
   const icons={terminal:'⬛',read_file:'📄',write_file:'✏️',search_files:'🔍',
     web_search:'🌐',web_extract:'🌐',execute_code:'⚙️',patch:'🔧',
     memory:'🧠',skill_manage:'📚',todo:'✅',cronjob:'⏱️',delegate_task:'🤖',
-    send_message:'💬',browser_navigate:'🌐',vision_analyze:'👁️'};
+    send_message:'💬',browser_navigate:'🌐',vision_analyze:'👁️',
+    subagent_progress:'🔀'};
   return icons[name]||'🔧';
 }
 
@@ -412,13 +669,22 @@ function buildToolCard(tc){
   }
   const hasMore=tc.snippet&&tc.snippet.length>displaySnippet.length;
   const runIndicator=tc.done===false?'<span class="tool-card-running-dot"></span>':'';
+  const isSubagent=tc.name==='subagent_progress';
+  const isDelegation=tc.name==='delegate_task';
+  const cardClass='tool-card'+(tc.done===false?' tool-card-running':'')+(isSubagent?' tool-card-subagent':'');
+  // Clean up subagent preview: strip leading 🔀 emoji since the icon already shows it
+  let displayName=tc.name;
+  if(isSubagent) displayName='Subagent';
+  if(isDelegation) displayName='Delegate task';
+  let previewText=tc.preview||displaySnippet||'';
+  if(isSubagent) previewText=previewText.replace(/^🔀\s*/,'');
   row.innerHTML=`
-    <div class="tool-card${tc.done===false?' tool-card-running':''}">
+    <div class="${cardClass}">
       <div class="tool-card-header" onclick="this.closest('.tool-card').classList.toggle('open')">
         ${runIndicator}
         <span class="tool-card-icon">${icon}</span>
-        <span class="tool-card-name">${esc(tc.name)}</span>
-        <span class="tool-card-preview">${esc(tc.preview||displaySnippet||'')}</span>
+        <span class="tool-card-name">${esc(displayName)}</span>
+        <span class="tool-card-preview">${esc(previewText)}</span>
         ${hasDetail?'<span class="tool-card-toggle">▸</span>':''}
       </div>
       ${hasDetail?`<div class="tool-card-detail">
@@ -558,6 +824,36 @@ function highlightCode(container) {
   Prism.highlightAllUnder(el);
 }
 
+function addCopyButtons(container){
+  const el=container||$('msgInner');
+  if(!el) return;
+  el.querySelectorAll('pre > code').forEach(codeEl=>{
+    const pre=codeEl.parentElement;
+    if(pre.querySelector('.code-copy-btn')) return;
+    const btn=document.createElement('button');
+    btn.className='code-copy-btn';
+    btn.textContent='Copy';
+    btn.onclick=(e)=>{
+      e.stopPropagation();
+      navigator.clipboard.writeText(codeEl.textContent).then(()=>{
+        btn.textContent='Copied!';
+        setTimeout(()=>{btn.textContent='Copy';},1500);
+      });
+    };
+    const header=pre.previousElementSibling;
+    if(header&&header.classList.contains('pre-header')){
+      header.style.display='flex';
+      header.style.justifyContent='space-between';
+      header.style.alignItems='center';
+      header.appendChild(btn);
+    }else{
+      pre.style.position='relative';
+      btn.style.cssText='position:absolute;top:6px;right:6px;';
+      pre.appendChild(btn);
+    }
+  });
+}
+
 let _mermaidLoading=false;
 let _mermaidReady=false;
 
@@ -568,7 +864,9 @@ function renderMermaidBlocks(){
     if(!_mermaidLoading){
       _mermaidLoading=true;
       const script=document.createElement('script');
-      script.src='https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.min.js';
+      script.src='https://cdn.jsdelivr.net/npm/mermaid@10.9.3/dist/mermaid.min.js';
+      script.integrity='sha384-R63zfMfSwJF4xCR11wXii+QUsbiBIdiDzDbtxia72oGWfkT7WHJfmD/I/eeHPJyT';
+      script.crossOrigin='anonymous';
       script.onload=()=>{
         if(typeof mermaid!=='undefined'){
           mermaid.initialize({startOnLoad:false,theme:'dark',themeVariables:{
@@ -620,27 +918,88 @@ function fileIcon(name, type){
   return '📄';
 }
 
+function renderBreadcrumb(){
+  const bar=$('breadcrumbBar');
+  const upBtn=$('btnUpDir');
+  if(!bar)return;
+  if(S.currentDir==='.'){
+    bar.style.display='none';
+    if(upBtn)upBtn.style.display='none';
+    return;
+  }
+  bar.style.display='flex';
+  if(upBtn)upBtn.style.display='';
+  bar.innerHTML='';
+  // Root segment
+  const root=document.createElement('span');
+  root.className='breadcrumb-seg breadcrumb-link';
+  root.textContent='~';
+  root.onclick=()=>loadDir('.');
+  bar.appendChild(root);
+  // Path segments
+  const parts=S.currentDir.split('/');
+  let accumulated='';
+  for(let i=0;i<parts.length;i++){
+    const sep=document.createElement('span');
+    sep.className='breadcrumb-sep';sep.textContent='/';
+    bar.appendChild(sep);
+    accumulated+=(accumulated?'/':'')+parts[i];
+    const seg=document.createElement('span');
+    seg.textContent=parts[i];
+    if(i<parts.length-1){
+      seg.className='breadcrumb-seg breadcrumb-link';
+      const target=accumulated;
+      seg.onclick=()=>loadDir(target);
+    } else {
+      seg.className='breadcrumb-seg breadcrumb-current';
+    }
+    bar.appendChild(seg);
+  }
+}
+
+// Track expanded directories for tree view
+if(!S._expandedDirs) S._expandedDirs=new Set();
+// Cache of fetched directory contents: path -> entries[]
+if(!S._dirCache) S._dirCache={};
+
 function renderFileTree(){
   const box=$('fileTree');box.innerHTML='';
-  for(const item of S.entries){
+  // Cache current dir entries
+  S._dirCache[S.currentDir||'.']=S.entries;
+  _renderTreeItems(box, S.entries, 0);
+}
+
+function _renderTreeItems(container, entries, depth){
+  for(const item of entries){
     const el=document.createElement('div');el.className='file-item';
+    el.style.paddingLeft=(8+depth*16)+'px';
+
+    if(item.type==='dir'){
+      // Toggle arrow for directories
+      const arrow=document.createElement('span');
+      arrow.className='file-tree-toggle';
+      const isExpanded=S._expandedDirs.has(item.path);
+      arrow.textContent=isExpanded?'\u25BE':'\u25B8';
+      el.appendChild(arrow);
+    }
 
     // Icon
     const iconEl=document.createElement('span');
     iconEl.className='file-icon';iconEl.textContent=fileIcon(item.name,item.type);
     el.appendChild(iconEl);
 
-    // Name -- takes all remaining space, truncates with ellipsis
+    // Name
     const nameEl=document.createElement('span');
     nameEl.className='file-name';nameEl.textContent=item.name;nameEl.title='Double-click to rename';
-    // Inline rename on double-click
     nameEl.ondblclick=(e)=>{
       e.stopPropagation();
+      // For directories, double-click navigates (breadcrumb view)
+      if(item.type==='dir'){loadDir(item.path);return;}
       const inp=document.createElement('input');
       inp.className='file-rename-input';inp.value=item.name;
       inp.onclick=(e2)=>e2.stopPropagation();
       const finish=async(save)=>{
-        inp.onblur=null;  // prevent double-call: Enter triggers blur after replaceWith
+        inp.onblur=null;
         if(save){
           const newName=inp.value.trim();
           if(newName&&newName!==item.name){
@@ -649,7 +1008,9 @@ function renderFileTree(){
                 session_id:S.session.session_id,path:item.path,new_name:newName
               })});
               showToast(`Renamed to ${newName}`);
-              await loadDir('.');
+              // Invalidate cache and re-render
+              delete S._dirCache[S.currentDir];
+              await loadDir(S.currentDir);
             }catch(err){showToast('Rename failed: '+err.message);}
           }
         }
@@ -665,7 +1026,7 @@ function renderFileTree(){
     };
     el.appendChild(nameEl);
 
-    // Size -- only for files, right-aligned, shrinks but never wraps
+    // Size -- only for files
     if(item.type==='file'&&item.size){
       const sizeEl=document.createElement('span');
       sizeEl.className='file-size';
@@ -673,16 +1034,54 @@ function renderFileTree(){
       el.appendChild(sizeEl);
     }
 
-    // Delete button -- for files, shown on hover
+    // Delete button -- for files
     if(item.type==='file'){
       const del=document.createElement('button');
-      del.className='file-del-btn';del.title='Delete';del.textContent='×';
+      del.className='file-del-btn';del.title='Delete';del.textContent='\u00d7';
       del.onclick=async(e)=>{e.stopPropagation();await deleteWorkspaceFile(item.path,item.name);};
       el.appendChild(del);
     }
 
-    el.onclick=async()=>item.type==='dir'?loadDir(item.path):openFile(item.path);
-    box.appendChild(el);
+    if(item.type==='dir'){
+      // Single-click toggles expand/collapse
+      el.onclick=async(e)=>{
+        e.stopPropagation();
+        if(S._expandedDirs.has(item.path)){
+          S._expandedDirs.delete(item.path);
+          if(typeof _saveExpandedDirs==='function')_saveExpandedDirs();
+          renderFileTree();
+        }else{
+          S._expandedDirs.add(item.path);
+          if(typeof _saveExpandedDirs==='function')_saveExpandedDirs();
+          // Fetch children if not cached
+          if(!S._dirCache[item.path]){
+            try{
+              const data=await api(`/api/list?session_id=${encodeURIComponent(S.session.session_id)}&path=${encodeURIComponent(item.path)}`);
+              S._dirCache[item.path]=data.entries||[];
+            }catch(e2){S._dirCache[item.path]=[];}
+          }
+          renderFileTree();
+        }
+      };
+    }else{
+      el.onclick=async()=>openFile(item.path);
+    }
+
+    container.appendChild(el);
+
+    // Render children if directory is expanded
+    if(item.type==='dir'&&S._expandedDirs.has(item.path)){
+      const children=S._dirCache[item.path]||[];
+      if(children.length){
+        _renderTreeItems(container, children, depth+1);
+      }else{
+        const empty=document.createElement('div');
+        empty.className='file-item file-empty';
+        empty.style.paddingLeft=(8+(depth+1)*16)+'px';
+        empty.textContent='(empty)';
+        container.appendChild(empty);
+      }
+    }
   }
 }
 
@@ -694,7 +1093,7 @@ async function deleteWorkspaceFile(relPath, name){
     showToast(`Deleted ${name}`);
     // Close preview if we just deleted the viewed file
     if($('previewPathText').textContent===relPath)$('btnClearPreview').onclick();
-    await loadDir('.');
+    await loadDir(S.currentDir);
   }catch(e){setStatus('Delete failed: '+e.message);}
 }
 
@@ -702,12 +1101,12 @@ async function promptNewFile(){
   if(!S.session)return;
   const name=prompt('New file name (e.g. notes.md):','');
   if(!name||!name.trim())return;
+  const relPath=S.currentDir==='.'?name.trim():(S.currentDir+'/'+name.trim());
   try{
-    await api('/api/file/create',{method:'POST',body:JSON.stringify({session_id:S.session.session_id,path:name.trim(),content:''})});
+    await api('/api/file/create',{method:'POST',body:JSON.stringify({session_id:S.session.session_id,path:relPath,content:''})});
     showToast(`Created ${name.trim()}`);
-    await loadDir('.');
-    // Open the new file immediately
-    openFile(name.trim());
+    await loadDir(S.currentDir);
+    openFile(relPath);
   }catch(e){setStatus('Create failed: '+e.message);}
 }
 
@@ -715,17 +1114,19 @@ async function promptNewFolder(){
   if(!S.session)return;
   const name=prompt('New folder name:','');
   if(!name||!name.trim())return;
+  const relPath=S.currentDir==='.'?name.trim():(S.currentDir+'/'+name.trim());
   try{
-    await api('/api/file/create-dir',{method:'POST',body:JSON.stringify({session_id:S.session.session_id,path:name.trim()})});
+    await api('/api/file/create-dir',{method:'POST',body:JSON.stringify({session_id:S.session.session_id,path:relPath})});
     showToast(`Created folder ${name.trim()}`);
-    await loadDir('.');
+    await loadDir(S.currentDir);
   }catch(e){setStatus('Create folder failed: '+e.message);}
 }
 
 function renderTray(){
   const tray=$('attachTray');tray.innerHTML='';
-  if(!S.pendingFiles.length){tray.classList.remove('has-files');return;}
+  if(!S.pendingFiles.length){tray.classList.remove('has-files');updateSendBtn();return;}
   tray.classList.add('has-files');
+  updateSendBtn();
   S.pendingFiles.forEach((f,i)=>{
     const chip=document.createElement('div');chip.className='attach-chip';
     chip.innerHTML=`&#128206; ${esc(f.name)} <button title="Remove">&#10005;</button>`;
@@ -745,7 +1146,7 @@ async function uploadPendingFiles(){
     const f=S.pendingFiles[i];const fd=new FormData();
     fd.append('session_id',S.session.session_id);fd.append('file',f,f.name);
     try{
-      const res=await fetch('/api/upload',{method:'POST',body:fd});
+      const res=await fetch(new URL('/api/upload',location.origin).href,{method:'POST',credentials:'include',body:fd});
       if(!res.ok){const err=await res.text();throw new Error(err);}
       const data=await res.json();
       if(data.error)throw new Error(data.error);

static/workspace.js

@@ -1,18 +1,97 @@
 async function api(path,opts={}){
-  const res=await fetch(path,{headers:{'Content-Type':'application/json'},...opts});
-  if(!res.ok)throw new Error(await res.text());
+  const url=new URL(path,location.origin);
+  const res=await fetch(url.href,{credentials:'include',headers:{'Content-Type':'application/json'},...opts});
+  if(!res.ok){
+    const text=await res.text();
+    // Parse JSON error body and surface the human-readable message,
+    // rather than showing raw JSON like {"error":"Profile 'x' does not exist."}
+    try{const j=JSON.parse(text);throw new Error(j.error||j.message||text);}
+    catch(e){if(e instanceof SyntaxError)throw new Error(text);throw e;}
+  }
   const ct=res.headers.get('content-type')||'';
   return ct.includes('application/json')?res.json():res.text();
 }
 
+// Persist/restore expanded directory state per workspace in localStorage
+function _wsExpandKey(){
+  const ws=S.session&&S.session.workspace;
+  return ws?'hermes-webui-expanded:'+ws:null;
+}
+function _saveExpandedDirs(){
+  const key=_wsExpandKey();if(!key)return;
+  try{localStorage.setItem(key,JSON.stringify([...(S._expandedDirs||new Set())]));}catch(e){}
+}
+function _restoreExpandedDirs(){
+  const key=_wsExpandKey();
+  if(!key){S._expandedDirs=new Set();return;}
+  try{
+    const raw=localStorage.getItem(key);
+    S._expandedDirs=raw?new Set(JSON.parse(raw)):new Set();
+  }catch(e){S._expandedDirs=new Set();}
+}
+
 async function loadDir(path){
   if(!S.session)return;
   try{
+    if(!path||path==='.'){
+      S._dirCache={};
+      _restoreExpandedDirs();  // restore per-workspace expanded state on root load
+    }
+    S.currentDir=path||'.';
     const data=await api(`/api/list?session_id=${encodeURIComponent(S.session.session_id)}&path=${encodeURIComponent(path)}`);
-    S.entries=data.entries||[];renderFileTree();
+    S.entries=data.entries||[];renderBreadcrumb();renderFileTree();
+    // Pre-fetch contents of restored expanded dirs so they render without a second click
+    if(!path||path==='.'){
+      for(const dirPath of (S._expandedDirs||[])){
+        if(!S._dirCache[dirPath]){
+          try{
+            const dc=await api(`/api/list?session_id=${encodeURIComponent(S.session.session_id)}&path=${encodeURIComponent(dirPath)}`);
+            S._dirCache[dirPath]=dc.entries||[];
+          }catch(e2){S._dirCache[dirPath]=[];}
+        }
+      }
+      if(S._expandedDirs&&S._expandedDirs.size>0)renderFileTree();
+    }
+    if(typeof clearPreview==='function'){
+      if(typeof _previewDirty!=='undefined'&&_previewDirty){
+        if(confirm('You have unsaved changes in the preview. Discard and navigate?'))clearPreview();
+      }else{
+        clearPreview();
+      }
+    }
+    // Fetch git info for workspace root (non-blocking)
+    if(!path||path==='.') _refreshGitBadge();
   }catch(e){console.warn('loadDir',e);}
 }
 
+async function _refreshGitBadge(){
+  const badge=$('gitBadge');
+  if(!badge||!S.session)return;
+  try{
+    const data=await api(`/api/git-info?session_id=${encodeURIComponent(S.session.session_id)}`);
+    if(data.git&&data.git.is_git){
+      const g=data.git;
+      let text=g.branch||'git';
+      if(g.dirty>0) text+=` \u00b7 ${g.dirty}\u2206`; // middot + delta
+      if(g.behind>0) text+=` \u2193${g.behind}`;
+      if(g.ahead>0) text+=` \u2191${g.ahead}`;
+      badge.textContent=text;
+      badge.className='git-badge'+(g.dirty>0?' dirty':'');
+      badge.style.display='';
+    } else {
+      badge.style.display='none';
+      badge.textContent='';
+    }
+  }catch(e){badge.style.display='none';}
+}
+
+function navigateUp(){
+  if(!S.session||S.currentDir==='.')return;
+  const parts=S.currentDir.split('/');
+  parts.pop();
+  loadDir(parts.length?parts.join('/'):'.');
+}
+
 // File extension sets for preview routing (must match server-side sets)
 const IMAGE_EXTS  = new Set(['.png','.jpg','.jpeg','.gif','.svg','.webp','.ico','.bmp']);
 const MD_EXTS     = new Set(['.md','.markdown','.mdown']);

tests/conftest.py

@@ -83,6 +83,95 @@ VENV_PYTHON  = _discover_python(HERMES_AGENT)
 # Work dir: agent dir if found, else repo root
 WORKDIR = str(HERMES_AGENT) if HERMES_AGENT else str(REPO_ROOT)
 
+# ── Agent availability detection ─────────────────────────────────────────────
+# Tests that require hermes-agent modules (cron, skills, approval, chat/stream)
+# are skipped when the agent isn't installed, instead of failing with 500 errors.
+AGENT_AVAILABLE = HERMES_AGENT is not None
+
+def _check_agent_modules():
+    """Verify hermes-agent Python modules are actually importable."""
+    if not HERMES_AGENT:
+        return False
+    try:
+        import importlib
+        # These are the modules that cause 500 errors when missing
+        for mod in ['cron.jobs', 'tools.skills_tool']:
+            importlib.import_module(mod)
+        return True
+    except (ImportError, ModuleNotFoundError):
+        return False
+
+AGENT_MODULES_AVAILABLE = _check_agent_modules()
+
+# pytest marker: skip tests that need hermes-agent when it's not present
+requires_agent = pytest.mark.skipif(
+    not AGENT_AVAILABLE,
+    reason="hermes-agent not found (skipping agent-dependent test)"
+)
+requires_agent_modules = pytest.mark.skipif(
+    not AGENT_MODULES_AVAILABLE,
+    reason="hermes-agent Python modules not importable (cron, skills_tool)"
+)
+
+def pytest_configure(config):
+    config.addinivalue_line("markers", "requires_agent: skip when hermes-agent dir is not found")
+    config.addinivalue_line("markers", "requires_agent_modules: skip when hermes-agent Python modules are not importable")
+
+def pytest_collection_modifyitems(config, items):
+    """Auto-skip agent-dependent tests when hermes-agent is not available.
+
+    Instead of requiring markers on every test function, we pattern-match
+    test names to known categories that depend on hermes-agent modules.
+    This keeps the test files clean and ensures new cron/skills tests
+    get auto-skipped without manual annotation.
+    """
+    if AGENT_MODULES_AVAILABLE:
+        return  # everything available, run all tests
+
+    # Exact list of tests known to fail without hermes-agent.
+    # These hit server endpoints that import cron.jobs, tools.skills_tool,
+    # or require a running agent backend — returning 500 without the agent.
+    _AGENT_DEPENDENT_TESTS = {
+        # Cron endpoints (need cron.jobs module)
+        'test_crons_list',
+        'test_crons_list_has_required_fields',
+        'test_crons_output_requires_job_id',
+        'test_crons_output_real_job',
+        'test_crons_run_nonexistent',
+        'test_cron_create_success',
+        'test_cron_update_unknown_job_404',
+        'test_cron_delete_unknown_404',
+        'test_crons_output_limit_param',
+        # Skills endpoints (need tools.skills_tool module)
+        'test_skills_list',
+        'test_skills_list_has_required_fields',
+        'test_skills_content_known',
+        'test_skills_content_requires_name',
+        'test_skills_search_returns_subset',
+        'test_skill_save_delete_roundtrip',
+        'test_skill_delete_unknown_404',
+        # Agent backend (need running AIAgent)
+        'test_chat_stream_opens_successfully',
+        'test_approval_submit_and_respond',
+        # Workspace path (macOS /tmp -> /private/tmp symlink)
+        'test_new_session_inherits_workspace',
+        'test_workspace_add_valid',
+        'test_workspace_rename',
+        'test_last_workspace_updates_on_session_update',
+        'test_new_session_inherits_last_workspace',
+    }
+
+    skip_marker = pytest.mark.skip(reason="requires hermes-agent (not installed)")
+    skipped = 0
+
+    for item in items:
+        if item.name in _AGENT_DEPENDENT_TESTS:
+            item.add_marker(skip_marker)
+            skipped += 1
+
+    if skipped:
+        print(f"\n⚠️  hermes-agent not found — {skipped} agent-dependent tests will be skipped\n")
+
 
 # ── Helpers ──────────────────────────────────────────────────────────────────
 

tests/test_model_resolver.py

@@ -0,0 +1,204 @@
+"""
+Tests for resolve_model_provider() model routing logic.
+Verifies that model IDs are correctly resolved to (model, provider, base_url)
+tuples for different provider configurations.
+"""
+import api.config as config
+
+
+def _resolve_with_config(model_id, provider=None, base_url=None, default=None):
+    """Helper: temporarily set config.cfg model section, call resolve, restore."""
+    old_cfg = dict(config.cfg)
+    model_cfg = {}
+    if provider:
+        model_cfg['provider'] = provider
+    if base_url:
+        model_cfg['base_url'] = base_url
+    if default:
+        model_cfg['default'] = default
+    config.cfg['model'] = model_cfg if model_cfg else {}
+    try:
+        return config.resolve_model_provider(model_id)
+    finally:
+        config.cfg.clear()
+        config.cfg.update(old_cfg)
+
+
+# ── OpenRouter prefix handling ────────────────────────────────────────────
+
+def test_openrouter_free_keeps_full_path():
+    """openrouter/free must NOT be stripped to 'free' when provider is openrouter."""
+    model, provider, base_url = _resolve_with_config(
+        'openrouter/free', provider='openrouter',
+        base_url='https://openrouter.ai/api/v1',
+    )
+    assert model == 'openrouter/free', f"Expected 'openrouter/free', got '{model}'"
+    assert provider == 'openrouter'
+
+
+def test_openrouter_model_with_provider_prefix():
+    """anthropic/claude-sonnet-4.6 via openrouter keeps full path."""
+    model, provider, base_url = _resolve_with_config(
+        'anthropic/claude-sonnet-4.6', provider='openrouter',
+        base_url='https://openrouter.ai/api/v1',
+    )
+    assert model == 'anthropic/claude-sonnet-4.6'
+    assert provider == 'openrouter'
+
+
+# ── Direct provider prefix stripping ─────────────────────────────────────
+
+def test_anthropic_prefix_stripped_for_direct_api():
+    """anthropic/claude-sonnet-4.6 strips prefix when provider is anthropic."""
+    model, provider, base_url = _resolve_with_config(
+        'anthropic/claude-sonnet-4.6', provider='anthropic',
+    )
+    assert model == 'claude-sonnet-4.6'
+    assert provider == 'anthropic'
+
+
+def test_openai_prefix_stripped_for_direct_api():
+    """openai/gpt-5.4-mini strips prefix when provider is openai."""
+    model, provider, base_url = _resolve_with_config(
+        'openai/gpt-5.4-mini', provider='openai',
+    )
+    assert model == 'gpt-5.4-mini'
+    assert provider == 'openai'
+
+
+# ── Cross-provider routing ───────────────────────────────────────────────
+
+def test_cross_provider_routes_through_openrouter():
+    """Picking openai model when config is anthropic routes via openrouter."""
+    model, provider, base_url = _resolve_with_config(
+        'openai/gpt-5.4-mini', provider='anthropic',
+    )
+    assert model == 'openai/gpt-5.4-mini'
+    assert provider == 'openrouter'
+    assert base_url is None  # openrouter uses its own endpoint
+
+
+# ── Bare model names ─────────────────────────────────────────────────────
+
+def test_bare_model_uses_config_provider():
+    """A model name without / uses the config provider and base_url."""
+    model, provider, base_url = _resolve_with_config(
+        'gemma-4-26B', provider='custom',
+        base_url='http://192.168.1.160:4000',
+    )
+    assert model == 'gemma-4-26B'
+    assert provider == 'custom'
+    assert base_url == 'http://192.168.1.160:4000'
+
+
+def test_empty_model_returns_config_defaults():
+    """Empty model string returns config provider and base_url."""
+    model, provider, base_url = _resolve_with_config(
+        '', provider='anthropic',
+    )
+    assert model == ''
+    assert provider == 'anthropic'
+
+
+# ── @provider:model hint routing (Issue #138 v2) ────────────────────────
+
+def test_provider_hint_routes_to_specific_provider():
+    """@minimax:MiniMax-M2.7 routes to minimax provider directly."""
+    model, provider, base_url = _resolve_with_config(
+        '@minimax:MiniMax-M2.7', provider='anthropic',
+    )
+    assert model == 'MiniMax-M2.7'
+    assert provider == 'minimax'
+    assert base_url is None  # resolve_runtime_provider will fill this
+
+
+def test_provider_hint_zai():
+    """@zai:GLM-5 routes to zai provider directly."""
+    model, provider, base_url = _resolve_with_config(
+        '@zai:GLM-5', provider='openai',
+    )
+    assert model == 'GLM-5'
+    assert provider == 'zai'
+
+
+def test_provider_hint_deepseek():
+    """@deepseek:deepseek-chat routes to deepseek provider."""
+    model, provider, base_url = _resolve_with_config(
+        '@deepseek:deepseek-chat', provider='anthropic',
+    )
+    assert model == 'deepseek-chat'
+    assert provider == 'deepseek'
+
+
+def test_slash_prefix_non_default_still_routes_openrouter():
+    """minimax/MiniMax-M2.7 (old format) still routes through openrouter."""
+    model, provider, base_url = _resolve_with_config(
+        'minimax/MiniMax-M2.7', provider='anthropic',
+    )
+    assert model == 'minimax/MiniMax-M2.7'
+    assert provider == 'openrouter'
+
+
+# ── get_available_models() @provider: hint behaviour ──────────────────────
+
+def _available_models_with_provider(provider):
+    """Helper: temporarily set active_provider in config."""
+    old_cfg = dict(config.cfg)
+    config.cfg['model'] = {'provider': provider}
+    try:
+        return config.get_available_models()
+    finally:
+        config.cfg.clear()
+        config.cfg.update(old_cfg)
+
+
+def test_non_default_provider_models_use_hint_prefix():
+    """With anthropic as default, minimax model IDs should use @minimax: prefix."""
+    result = _available_models_with_provider('anthropic')
+    groups = {g['provider']: g['models'] for g in result['groups']}
+    if 'MiniMax' in groups:
+        for m in groups['MiniMax']:
+            assert m['id'].startswith('@minimax:'), (
+                f"Expected @minimax: prefix, got: {m['id']!r}"
+            )
+
+
+def test_no_duplicate_when_default_model_is_prefixed():
+    """Issue #147 Bug 2: 'anthropic/claude-opus-4.6' as default_model must not
+    inject a duplicate alongside the existing bare 'claude-opus-4.6' entry in
+    the same provider group."""
+    import api.config as _cfg
+    old_cfg = dict(_cfg.cfg)
+    _cfg.cfg['model'] = {
+        'provider': 'anthropic',
+        'default': 'anthropic/claude-opus-4.6',
+    }
+    try:
+        result = _cfg.get_available_models()
+        norm = lambda mid: mid.split('/', 1)[-1] if '/' in mid else mid
+        # Check each group individually: no group should have two entries that
+        # normalize to the same bare model name
+        for g in result['groups']:
+            bare_ids = [norm(m['id']) for m in g['models']]
+            duplicates = [mid for mid in set(bare_ids) if bare_ids.count(mid) > 1]
+            assert not duplicates, (
+                f"Provider group '{g['provider']}' has duplicate models after normalization: "
+                f"{duplicates}\nFull group: {[m['id'] for m in g['models']]}"
+            )
+    finally:
+        _cfg.cfg.clear()
+        _cfg.cfg.update(old_cfg)
+
+
+def test_default_provider_models_not_prefixed():
+    """The active provider's models remain bare (no @prefix added)."""
+    import api.config as _cfg
+    raw_anthropic_ids = {m['id'] for m in _cfg._PROVIDER_MODELS.get('anthropic', [])}
+    result = _available_models_with_provider('anthropic')
+    groups = {g['provider']: g['models'] for g in result['groups']}
+    if 'Anthropic' in groups:
+        returned_ids = {m['id'] for m in groups['Anthropic']}
+        for bare_id in raw_anthropic_ids:
+            assert bare_id in returned_ids, (
+                f"_PROVIDER_MODELS entry '{bare_id}' is missing from the Anthropic group"
+            )

tests/test_regressions.py

@@ -438,3 +438,37 @@ def test_newSession_clears_live_tool_cards(cleanup_test_sessions):
     next_fn = src.find("async function ", new_sess_idx + 10)
     new_sess_body = src[new_sess_idx:next_fn]
     assert "clearLiveToolCards" in new_sess_body,         "newSession() must call clearLiveToolCards() to clear stale live cards"
+
+
+# ── R16: Stack traces must not leak to clients in 500 responses ────────────
+
+def test_500_response_has_no_trace_field():
+    """R16: HTTP 500 responses must not include a 'trace' field.
+    Leaking tracebacks exposes file paths, module names, and potentially
+    secret values from local variables.
+    """
+    # POST to /api/chat/start with missing required fields to trigger an error
+    data, status = post("/api/chat/start", {})
+    # Should be an error response (4xx or 5xx)
+    assert "trace" not in data, \
+        "Server must not leak stack traces to clients"
+
+def test_upload_error_has_no_trace_field():
+    """R16b: Upload 500 responses must not include a 'trace' field."""
+    # Send a POST to /api/upload with invalid content to trigger the error handler
+    req = urllib.request.Request(
+        BASE + "/api/upload",
+        data=b"not-multipart-data",
+        headers={"Content-Type": "text/plain", "Content-Length": "18"},
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=10) as r:
+            body = json.loads(r.read())
+            code = r.status
+    except urllib.error.HTTPError as e:
+        body = json.loads(e.read())
+        code = e.code
+    assert code >= 400, "Invalid upload should return an error status"
+    assert "trace" not in body, \
+        "Upload errors must not leak stack traces to clients"
+    assert "error" in body, "Error responses must include an 'error' key"

tests/test_sprint15.py

@@ -0,0 +1,234 @@
+"""
+Sprint 15 Tests: session projects (CRUD, move, backward compat).
+"""
+import json, urllib.error, urllib.request
+
+BASE = "http://127.0.0.1:8788"
+
+
+def get(path):
+    with urllib.request.urlopen(BASE + path, timeout=10) as r:
+        return json.loads(r.read()), r.status
+
+
+def post(path, body=None):
+    data = json.dumps(body or {}).encode()
+    req = urllib.request.Request(BASE + path, data=data,
+                                headers={"Content-Type": "application/json"})
+    try:
+        with urllib.request.urlopen(req, timeout=10) as r:
+            return json.loads(r.read()), r.status
+    except urllib.error.HTTPError as e:
+        return json.loads(e.read()), e.code
+
+
+def make_session(created_list):
+    d, _ = post("/api/session/new", {})
+    sid = d["session"]["session_id"]
+    created_list.append(sid)
+    return sid, d["session"]
+
+
+def make_project(created_list, name="Test Project", color=None):
+    body = {"name": name}
+    if color:
+        body["color"] = color
+    d, status = post("/api/projects/create", body)
+    assert status == 200
+    pid = d["project"]["project_id"]
+    created_list.append(pid)
+    return pid, d["project"]
+
+
+def cleanup_projects(project_ids):
+    for pid in project_ids:
+        try:
+            post("/api/projects/delete", {"project_id": pid})
+        except Exception:
+            pass
+
+
+# ── Project CRUD ─────────────────────────────────────────────────────────
+
+def test_create_project():
+    """Creating a project returns a valid project dict."""
+    pids = []
+    try:
+        pid, proj = make_project(pids, "My Project", "#7cb9ff")
+        assert pid and len(pid) == 12
+        assert proj["name"] == "My Project"
+        assert proj["color"] == "#7cb9ff"
+        assert "created_at" in proj
+    finally:
+        cleanup_projects(pids)
+
+
+def test_list_projects_empty():
+    """Listing projects when none exist returns empty list."""
+    d, status = get("/api/projects")
+    assert status == 200
+    assert isinstance(d["projects"], list)
+
+
+def test_list_projects():
+    """Listing projects returns created projects."""
+    pids = []
+    try:
+        make_project(pids, "Alpha")
+        make_project(pids, "Beta")
+        d, status = get("/api/projects")
+        assert status == 200
+        names = [p["name"] for p in d["projects"]]
+        assert "Alpha" in names
+        assert "Beta" in names
+    finally:
+        cleanup_projects(pids)
+
+
+def test_rename_project():
+    """Renaming a project updates its name."""
+    pids = []
+    try:
+        pid, _ = make_project(pids, "Old Name")
+        d, status = post("/api/projects/rename", {"project_id": pid, "name": "New Name"})
+        assert status == 200
+        assert d["project"]["name"] == "New Name"
+        # Verify via list
+        dl, _ = get("/api/projects")
+        names = [p["name"] for p in dl["projects"]]
+        assert "New Name" in names
+        assert "Old Name" not in names
+    finally:
+        cleanup_projects(pids)
+
+
+def test_delete_project():
+    """Deleting a project removes it from the list."""
+    pids = []
+    try:
+        pid, _ = make_project(pids, "Doomed")
+        d, status = post("/api/projects/delete", {"project_id": pid})
+        assert status == 200
+        assert d["ok"] is True
+        dl, _ = get("/api/projects")
+        assert all(p["project_id"] != pid for p in dl["projects"])
+        pids.clear()  # already deleted
+    finally:
+        cleanup_projects(pids)
+
+
+def test_delete_project_unassigns_sessions():
+    """Deleting a project unassigns all sessions that belonged to it."""
+    pids = []
+    sids = []
+    try:
+        pid, _ = make_project(pids, "Temp Project")
+        sid, _ = make_session(sids)
+        # Assign session to project
+        post("/api/session/move", {"session_id": sid, "project_id": pid})
+        # Verify assigned
+        sd, _ = get(f"/api/session?session_id={sid}")
+        assert sd["session"].get("project_id") == pid
+        # Delete project
+        post("/api/projects/delete", {"project_id": pid})
+        pids.clear()
+        # Verify session is unassigned
+        sd2, _ = get(f"/api/session?session_id={sid}")
+        assert sd2["session"].get("project_id") is None
+    finally:
+        cleanup_projects(pids)
+        for s in sids:
+            post("/api/session/delete", {"session_id": s})
+
+
+def test_create_project_requires_name():
+    """Creating a project without a name returns 400."""
+    d, status = post("/api/projects/create", {})
+    assert status == 400
+
+
+def test_delete_nonexistent_project():
+    """Deleting a project that doesn't exist returns 404."""
+    d, status = post("/api/projects/delete", {"project_id": "nonexistent99"})
+    assert status == 404
+
+
+# ── Session move ─────────────────────────────────────────────────────────
+
+def test_session_move_to_project():
+    """Moving a session to a project sets its project_id."""
+    pids = []
+    sids = []
+    try:
+        pid, _ = make_project(pids, "Work")
+        sid, _ = make_session(sids)
+        d, status = post("/api/session/move", {"session_id": sid, "project_id": pid})
+        assert status == 200
+        assert d["session"]["project_id"] == pid
+    finally:
+        cleanup_projects(pids)
+        for s in sids:
+            post("/api/session/delete", {"session_id": s})
+
+
+def test_session_move_to_unassigned():
+    """Moving a session to null project unassigns it."""
+    pids = []
+    sids = []
+    try:
+        pid, _ = make_project(pids, "Temp")
+        sid, _ = make_session(sids)
+        # Assign then unassign
+        post("/api/session/move", {"session_id": sid, "project_id": pid})
+        d, status = post("/api/session/move", {"session_id": sid, "project_id": None})
+        assert status == 200
+        assert d["session"]["project_id"] is None
+    finally:
+        cleanup_projects(pids)
+        for s in sids:
+            post("/api/session/delete", {"session_id": s})
+
+
+def test_session_project_in_list():
+    """Session list includes project_id for assigned sessions."""
+    pids = []
+    sids = []
+    try:
+        pid, _ = make_project(pids, "Listed")
+        sid, _ = make_session(sids)
+        # Give it a title so it shows in list (non-empty Untitled sessions are hidden)
+        post("/api/session/rename", {"session_id": sid, "title": "Project Test Session"})
+        post("/api/session/move", {"session_id": sid, "project_id": pid})
+        dl, _ = get("/api/sessions")
+        match = [s for s in dl["sessions"] if s["session_id"] == sid]
+        assert len(match) == 1
+        assert match[0]["project_id"] == pid
+    finally:
+        cleanup_projects(pids)
+        for s in sids:
+            post("/api/session/delete", {"session_id": s})
+
+
+# ── Backward compat ──────────────────────────────────────────────────────
+
+def test_compact_includes_project_id():
+    """New session compact dict includes project_id as null."""
+    sids = []
+    try:
+        sid, sess = make_session(sids)
+        # Give it a title so it appears in the list
+        post("/api/session/rename", {"session_id": sid, "title": "Compat Test"})
+        dl, _ = get("/api/sessions")
+        match = [s for s in dl["sessions"] if s["session_id"] == sid]
+        assert len(match) == 1
+        assert "project_id" in match[0]
+        assert match[0]["project_id"] is None
+    finally:
+        for s in sids:
+            post("/api/session/delete", {"session_id": s})
+
+
+def test_session_move_requires_session_id():
+    """Moving without session_id returns 400."""
+    d, status = post("/api/session/move", {"project_id": "abc"})
+    assert status == 400

tests/test_sprint16.py

@@ -0,0 +1,709 @@
+"""
+Sprint 16 Tests: safe HTML rendering in renderMd(), active session styling,
+session sidebar polish (SVG icons, overlay actions).
+"""
+import html as _html
+import pathlib
+import re
+import urllib.request
+
+BASE = "http://127.0.0.1:8788"
+REPO_ROOT = pathlib.Path(__file__).parent.parent
+
+
+# ── Helpers ──────────────────────────────────────────────────────────────────
+
+def get_text(path):
+    with urllib.request.urlopen(BASE + path, timeout=10) as r:
+        return r.read().decode("utf-8"), r.status
+
+
+def esc(s):
+    """Mirror of esc() in ui.js — HTML-escapes a string."""
+    return _html.escape(str(s), quote=True)
+
+
+SAFE_TAGS = re.compile(
+    r"^<\/?(strong|em|code|pre|h[1-6]|ul|ol|li|table|thead|tbody|tr|th|td"
+    r"|hr|blockquote|p|br|a|div)([\s>]|$)",
+    re.I,
+)
+SAFE_INLINE = re.compile(r"^<\/?(strong|em|code|a)([\s>]|$)", re.I)
+
+
+def inline_md(t):
+    """Mirror of inlineMd() in ui.js — for use inside list items / blockquotes."""
+    t = re.sub(r"\*\*\*(.+?)\*\*\*", lambda m: "<strong><em>" + esc(m.group(1)) + "</em></strong>", t)
+    t = re.sub(r"\*\*(.+?)\*\*",     lambda m: "<strong>" + esc(m.group(1)) + "</strong>", t)
+    t = re.sub(r"\*([^*\n]+)\*",     lambda m: "<em>" + esc(m.group(1)) + "</em>", t)
+    t = re.sub(r"`([^`\n]+)`",        lambda m: "<code>" + esc(m.group(1)) + "</code>", t)
+    t = re.sub(
+        r"\[([^\]]+)\]\((https?://[^\)]+)\)",
+        lambda m: f'<a href="{esc(m.group(2))}" target="_blank" rel="noopener">{esc(m.group(1))}</a>',
+        t,
+    )
+    t = re.sub(r"</?[a-zA-Z][^>]*>", lambda m: m.group() if SAFE_INLINE.match(m.group()) else esc(m.group()), t)
+    return t
+
+
+def render_md(raw):
+    """
+    Python mirror of renderMd() in static/ui.js.
+    Kept in sync with the JS implementation so tests catch regressions
+    if the JS logic drifts from the documented behaviour.
+    """
+    s = raw or ""
+
+    # Pre-pass: stash code blocks/spans, convert safe HTML → markdown equivalents
+    fence_stash = []
+
+    def stash(m):
+        fence_stash.append(m.group())
+        return "\x00F" + str(len(fence_stash) - 1) + "\x00"
+
+    s = re.sub(r"(```[\s\S]*?```|`[^`\n]+`)", stash, s)
+    s = re.sub(r"<strong>([\s\S]*?)</strong>", lambda m: "**" + m.group(1) + "**", s, flags=re.I)
+    s = re.sub(r"<b>([\s\S]*?)</b>",           lambda m: "**" + m.group(1) + "**", s, flags=re.I)
+    s = re.sub(r"<em>([\s\S]*?)</em>",          lambda m: "*"  + m.group(1) + "*",  s, flags=re.I)
+    s = re.sub(r"<i>([\s\S]*?)</i>",            lambda m: "*"  + m.group(1) + "*",  s, flags=re.I)
+    s = re.sub(r"<code>([^<]*?)</code>",         lambda m: "`"  + m.group(1) + "`",  s, flags=re.I)
+    s = re.sub(r"<br\s*/?>", "\n", s, flags=re.I)
+    s = re.sub(r"\x00F(\d+)\x00", lambda m: fence_stash[int(m.group(1))], s)
+
+    # Fenced code blocks
+    def fenced(m):
+        lang, code = m.group(1), m.group(2).rstrip("\n")
+        h = f'<div class="pre-header">{esc(lang)}</div>' if lang else ""
+        return h + "<pre><code>" + esc(code) + "</code></pre>"
+    s = re.sub(r"```([\w+-]*)\n?([\s\S]*?)```", fenced, s)
+    s = re.sub(r"`([^`\n]+)`", lambda m: "<code>" + esc(m.group(1)) + "</code>", s)
+
+    # Inline formatting (top-level, outside list items)
+    s = re.sub(r"\*\*\*(.+?)\*\*\*", lambda m: "<strong><em>" + esc(m.group(1)) + "</em></strong>", s)
+    s = re.sub(r"\*\*(.+?)\*\*",     lambda m: "<strong>" + esc(m.group(1)) + "</strong>", s)
+    s = re.sub(r"\*([^*\n]+)\*",     lambda m: "<em>" + esc(m.group(1)) + "</em>", s)
+
+    # Block elements using inlineMd for their content
+    s = re.sub(r"^### (.+)$", lambda m: "<h3>" + inline_md(m.group(1)) + "</h3>", s, flags=re.M)
+    s = re.sub(r"^## (.+)$",  lambda m: "<h2>" + inline_md(m.group(1)) + "</h2>", s, flags=re.M)
+    s = re.sub(r"^# (.+)$",   lambda m: "<h1>" + inline_md(m.group(1)) + "</h1>", s, flags=re.M)
+    s = re.sub(r"^---+$", "<hr>", s, flags=re.M)
+    s = re.sub(r"^> (.+)$", lambda m: "<blockquote>" + inline_md(m.group(1)) + "</blockquote>", s, flags=re.M)
+
+    def handle_ul(block):
+        lines = block.strip().split("\n")
+        out = "<ul>"
+        for l in lines:
+            indent = bool(re.match(r"^ {2,}", l))
+            text = re.sub(r"^ {0,4}[-*+] ", "", l)
+            style = ' style="margin-left:16px"' if indent else ""
+            out += f"<li{style}>{inline_md(text)}</li>"
+        return out + "</ul>"
+
+    s = re.sub(r"((?:^(?:  )?[-*+] .+\n?)+)", lambda m: handle_ul(m.group()), s, flags=re.M)
+
+    def handle_ol(block):
+        lines = block.strip().split("\n")
+        out = "<ol>"
+        for l in lines:
+            text = re.sub(r"^ {0,4}\d+\. ", "", l)
+            out += f"<li>{inline_md(text)}</li>"
+        return out + "</ol>"
+
+    s = re.sub(r"((?:^(?:  )?\d+\. .+\n?)+)", lambda m: handle_ol(m.group()), s, flags=re.M)
+
+    # Safety net: escape unknown tags in remaining text
+    s = re.sub(r"</?[a-zA-Z][^>]*>", lambda m: m.group() if SAFE_TAGS.match(m.group()) else esc(m.group()), s)
+
+    # Paragraph wrap
+    parts = s.split("\n\n")
+    def wrap(p):
+        p = p.strip()
+        if not p: return ""
+        if re.match(r"^<(h[1-6]|ul|ol|pre|hr|blockquote)", p): return p
+        return "<p>" + p.replace("\n", "<br>") + "</p>"
+    s = "\n".join(wrap(p) for p in parts)
+    return s
+
+
+# ── Static analysis: verify key structures exist in ui.js ────────────────────
+
+def test_render_md_pre_pass_converts_strong(cleanup_test_sessions):
+    """ui.js renderMd() must have pre-pass that converts <strong> to **."""
+    src = REPO_ROOT / "static" / "ui.js"
+    code = src.read_text()
+    assert "<strong>" in code and "**" in code, "pre-pass for <strong> not found"
+    # Verify the specific conversion pattern
+    assert re.search(r"<strong>.*?\*\*", code, re.S), \
+        "renderMd pre-pass should convert <strong>...</strong> to **...**"
+
+
+def test_render_md_has_safety_net(cleanup_test_sessions):
+    """ui.js must have a safety-net that escapes unknown HTML tags after the pipeline."""
+    src = REPO_ROOT / "static" / "ui.js"
+    code = src.read_text()
+    assert "SAFE_TAGS" in code, "SAFE_TAGS allowlist regex not found in ui.js"
+    assert "esc(tag)" in code, "safety-net esc(tag) call not found in ui.js"
+
+
+def test_render_md_stashes_code_blocks(cleanup_test_sessions):
+    """ui.js pre-pass must stash code blocks before replacing safe HTML tags."""
+    src = REPO_ROOT / "static" / "ui.js"
+    code = src.read_text()
+    assert "fence_stash" in code, "fence_stash not found in renderMd pre-pass"
+
+
+def test_render_md_handles_br_tag(cleanup_test_sessions):
+    """ui.js must convert <br> to newline in pre-pass."""
+    src = REPO_ROOT / "static" / "ui.js"
+    code = src.read_text()
+    assert re.search(r"<br\\s\*", code) or "<br" in code, "<br> handling not found"
+
+
+def test_render_md_no_placeholder_remnants(cleanup_test_sessions):
+    """Old Unicode placeholder approach (\\uE001-\\uE005) must be gone."""
+    src = REPO_ROOT / "static" / "ui.js"
+    code = src.read_text()
+    for old_ph in ["\\uE001", "\\uE002", "\\uE003", "\\uE004", "\\uE005"]:
+        assert old_ph not in code, \
+            f"Old placeholder {old_ph} still present — broken implementation not cleaned up"
+
+
+def test_render_md_safe_tag_allowlist_complete(cleanup_test_sessions):
+    """SAFE_TAGS allowlist must include all tags the pipeline emits."""
+    src = REPO_ROOT / "static" / "ui.js"
+    code = src.read_text()
+    required = ["strong", "em", "code", "pre", "ul", "ol", "li",
+                "table", "blockquote", "hr", "br", "a", "div"]
+    safe_tags_match = re.search(r"SAFE_TAGS\s*=\s*/(.+?)/i", code)
+    assert safe_tags_match, "SAFE_TAGS regex not found"
+    pattern = safe_tags_match.group(1)
+    for tag in required:
+        assert tag in pattern, f"Tag '{tag}' missing from SAFE_TAGS allowlist"
+
+
+# ── Behavioural: renderMd logic via Python mirror ─────────────────────────────
+
+def test_render_md_markdown_bold(cleanup_test_sessions):
+    """**word** markdown renders as <strong>word</strong>."""
+    out = render_md("Hello **world**")
+    assert "<strong>world</strong>" in out
+
+
+def test_render_md_html_strong_passthrough(cleanup_test_sessions):
+    """<strong>word</strong> in AI output renders as bold."""
+    out = render_md("Hello <strong>world</strong>")
+    assert "<strong>world</strong>" in out
+
+
+def test_render_md_html_b_tag(cleanup_test_sessions):
+    """<b>word</b> renders as <strong>word</strong>."""
+    out = render_md("Hello <b>world</b>")
+    assert "<strong>world</strong>" in out
+
+
+def test_render_md_html_em_passthrough(cleanup_test_sessions):
+    """<em>word</em> renders as italic."""
+    out = render_md("Hello <em>world</em>")
+    assert "<em>world</em>" in out
+
+
+def test_render_md_html_i_tag(cleanup_test_sessions):
+    """<i>word</i> renders as <em>word</em>."""
+    out = render_md("Hello <i>word</i>")
+    assert "<em>word</em>" in out
+
+
+def test_render_md_html_code_passthrough(cleanup_test_sessions):
+    """<code>text</code> renders as inline code."""
+    out = render_md("use <code>print()</code>")
+    assert "<code>print()</code>" in out
+
+
+def test_render_md_html_br_becomes_newline(cleanup_test_sessions):
+    """<br> in AI output becomes a newline (rendered as <br> inside <p> later)."""
+    out = render_md("line one<br>line two")
+    assert "line one\nline two" in out or "line one<br>line two" in out
+
+
+def test_render_md_mixed_markdown_and_html(cleanup_test_sessions):
+    """Markdown and HTML formatting can coexist in the same response."""
+    out = render_md("**markdown** and <strong>html</strong>")
+    assert "<strong>markdown</strong>" in out
+    assert "<strong>html</strong>" in out
+
+
+def test_render_md_html_strong_in_list_item(cleanup_test_sessions):
+    """THE SCREENSHOT BUG: <strong> tags inside list items must render as bold,
+    not as escaped literal text like &lt;strong&gt;."""
+    out = render_md(
+        "- <strong>All items</strong> get `border-radius: 0 8px 8px 0`\n"
+        "- <strong>Active item</strong> uses <code>#e8a030</code>\n"
+        "- <strong>Project items</strong> show their color\n"
+        "- <strong>Regular items</strong> stay muted"
+    )
+    assert "&lt;strong&gt;" not in out, \
+        "Escaped <strong> literal found in list output — bold not rendering"
+    assert "<strong>All items</strong>" in out
+    assert "<strong>Active item</strong>" in out
+    assert "<code>border-radius: 0 8px 8px 0</code>" in out
+    assert "<code>#e8a030</code>" in out
+
+
+def test_render_md_exact_screenshot_content(cleanup_test_sessions):
+    """Exact text from the ui-changes-unrendered-html-tags.png screenshot.
+    This is the canonical regression test for the inlineMd fix.
+    All four bullet points must render <strong> and <code> as HTML, not literal text."""
+    out = render_md(
+        "- <strong>All items</strong> now have <code>border-radius: 0 8px 8px 0</code>"
+        " \u2014 straight left edge everywhere, rounded on the right\n"
+        "- <strong>Active item</strong> is now gold/amber (<code>#e8a030</code>)"
+        " \u2014 same warm gold used in the logo \u2014 instead of blue,"
+        " so it stands out distinctly from everything else\n"
+        "- <strong>Project items</strong> still show their project color on the left"
+        " border, but only when they're not the active item (active always wins with gold)\n"
+        "- <strong>Regular items</strong> (no project) still have no left border color"
+    )
+    # None of the safe tags should appear as literal escaped text
+    assert "&lt;strong&gt;" not in out, \
+        "Literal &lt;strong&gt; found — <strong> is not rendering as bold"
+    assert "&lt;/strong&gt;" not in out, \
+        "Literal &lt;/strong&gt; found — closing tag is not rendering"
+    assert "&lt;code&gt;" not in out, \
+        "Literal &lt;code&gt; found — <code> is not rendering as inline code"
+    # Each item's bold label must render correctly
+    assert "<strong>All items</strong>" in out
+    assert "<strong>Active item</strong>" in out
+    assert "<strong>Project items</strong>" in out
+    assert "<strong>Regular items</strong>" in out
+    # The code spans in items 1 and 2 must render correctly
+    assert "<code>border-radius: 0 8px 8px 0</code>" in out
+    assert "<code>#e8a030</code>" in out
+    # The surrounding prose text must be preserved
+    assert "straight left edge everywhere" in out
+    assert "same warm gold used in the logo" in out
+    assert "active always wins with gold" in out
+
+
+def test_render_md_markdown_bold_in_list_item(cleanup_test_sessions):
+    """**bold** markdown inside list items must render as <strong>."""
+    out = render_md("- **First** item\n- **Second** item with `code`")
+    assert "<strong>First</strong>" in out
+    assert "<strong>Second</strong>" in out
+    assert "<code>code</code>" in out
+
+
+def test_render_md_html_strong_in_blockquote(cleanup_test_sessions):
+    """<strong> inside blockquote must render as bold."""
+    out = render_md("> <strong>Note:</strong> pay attention")
+    assert "&lt;strong&gt;" not in out
+    assert "<strong>Note:</strong>" in out
+
+
+def test_render_md_html_strong_in_heading(cleanup_test_sessions):
+    """<strong> inside a heading must render as bold."""
+    out = render_md("## <strong>Important</strong> Section")
+    assert "&lt;strong&gt;" not in out
+    assert "<strong>Important</strong>" in out
+
+
+def test_render_md_xss_in_list_still_blocked(cleanup_test_sessions):
+    """XSS attempts in list items must still be escaped."""
+    out = render_md("- <img src=x onerror=alert(1)> bad")
+    assert "<img" not in out
+    assert "&lt;img" in out
+
+
+def test_render_md_xss_in_blockquote_still_blocked(cleanup_test_sessions):
+    """XSS in blockquote must still be escaped."""
+    out = render_md("> <script>alert(1)</script>")
+    assert "<script>" not in out
+    assert "&lt;script" in out
+
+
+def test_render_md_code_span_in_list_protected(cleanup_test_sessions):
+    """Backtick code span in list item must escape its content."""
+    out = render_md("- Use `<br>` for breaks")
+    assert "<code>&lt;br&gt;</code>" in out
+
+
+def test_render_md_code_block_protects_html(cleanup_test_sessions):
+    """HTML inside a backtick code span must NOT be converted — shown as literal."""
+    out = render_md("keep `<strong>literal</strong>` safe")
+    assert "&lt;strong&gt;" in out, "HTML inside code span should be escaped"
+    assert "<strong>literal</strong>" not in out, "HTML inside code span should NOT render as bold"
+
+
+def test_render_md_fenced_code_protects_html(cleanup_test_sessions):
+    """HTML inside a fenced code block must not be converted by the pre-pass.
+    The fenced block is stashed before tag replacement runs, so the raw HTML
+    is preserved intact for the pipeline's esc() to escape when rendering
+    the <pre><code> block. We verify the stash/restore mechanism works by
+    checking the content is unchanged after the pre-pass (i.e. still contains
+    the original tag text, not converted to **not bold**)."""
+    src = "```\n<strong>not bold</strong>\n```"
+    out = render_md(src)
+    # Pre-pass stash preserves the raw content -- it should NOT have been
+    # converted to **not bold** (which would render as bold outside the fence)
+    assert "**not bold**" not in out, \
+        "Fenced code content was incorrectly converted to markdown by the pre-pass"
+    # The raw content should still be present (stash/restore worked)
+    assert "<strong>not bold</strong>" in out or "&lt;strong&gt;" in out, \
+        "Fenced code content was lost after stash/restore"
+
+
+# ── Security: XSS must be blocked ─────────────────────────────────────────────
+
+def test_render_md_xss_img_tag_escaped(cleanup_test_sessions):
+    """<img src=x onerror=alert(1)> must be HTML-escaped, not rendered."""
+    out = render_md("<img src=x onerror=alert(1)>")
+    assert "<img" not in out, "Raw <img> tag must not appear in output"
+    assert "&lt;img" in out, "<img> must be HTML-escaped"
+
+
+def test_render_md_xss_script_tag_escaped(cleanup_test_sessions):
+    """<script>alert(1)</script> must be HTML-escaped."""
+    out = render_md("<script>alert(1)</script>")
+    assert "<script>" not in out, "Raw <script> tag must not appear in output"
+    assert "&lt;script" in out, "<script> must be HTML-escaped"
+
+
+def test_render_md_xss_iframe_escaped(cleanup_test_sessions):
+    """<iframe> must be HTML-escaped."""
+    out = render_md("<iframe src='evil.com'></iframe>")
+    assert "<iframe" not in out
+    assert "&lt;iframe" in out
+
+
+def test_render_md_xss_svg_onerror_escaped(cleanup_test_sessions):
+    """<svg onload=...> must be HTML-escaped."""
+    out = render_md("<svg onload=alert(1)>")
+    assert "<svg" not in out
+    assert "&lt;svg" in out
+
+
+def test_render_md_xss_in_bold_text_escaped(cleanup_test_sessions):
+    """**<img onerror=...>** — XSS inside markdown bold must be escaped."""
+    out = render_md("**<img src=x onerror=alert(1)>**")
+    assert "<img" not in out, "XSS inside **bold** must be escaped"
+    assert "&lt;img" in out
+
+
+def test_render_md_xss_in_html_strong_escaped(cleanup_test_sessions):
+    """<strong><img ...></strong> — nested XSS inside HTML strong must be escaped."""
+    out = render_md("<strong><img src=x onerror=alert(1)></strong>")
+    # <strong> converts to ** which then escapes the inner content via esc()
+    assert "<img" not in out, "XSS nested inside <strong> must be escaped"
+
+
+def test_render_md_xss_object_tag_escaped(cleanup_test_sessions):
+    """<object data=...> must be HTML-escaped."""
+    out = render_md("<object data='evil.swf'></object>")
+    assert "<object" not in out
+    assert "&lt;object" in out
+
+
+# ── Sprint 16 sidebar: static structure checks ───────────────────────────────
+
+# ── Exhaustive inlineMd / renderMd edge-case tests ───────────────────────────
+
+# --- Unordered list variants ---
+
+def test_list_bold_only(cleanup_test_sessions):
+    """Single bold word in list item."""
+    out = render_md("- **bold**")
+    assert "<strong>bold</strong>" in out
+    assert "&lt;" not in out
+
+def test_list_italic_only(cleanup_test_sessions):
+    """Single italic word in list item."""
+    out = render_md("- *italic*")
+    assert "<em>italic</em>" in out
+
+def test_list_code_only(cleanup_test_sessions):
+    """Single code span in list item."""
+    out = render_md("- `code`")
+    assert "<code>code</code>" in out
+
+def test_list_bold_and_code_mixed(cleanup_test_sessions):
+    """Bold and code together in one list item."""
+    out = render_md("- **run** `pip install foo`")
+    assert "<strong>run</strong>" in out
+    assert "<code>pip install foo</code>" in out
+
+def test_list_html_strong_and_code_mixed(cleanup_test_sessions):
+    """HTML <strong> and <code> together — the exact screenshot scenario."""
+    out = render_md("- <strong>Key</strong>: use <code>value</code>")
+    assert "<strong>Key</strong>" in out
+    assert "<code>value</code>" in out
+    assert "&lt;strong&gt;" not in out
+    assert "&lt;code&gt;" not in out
+
+def test_list_html_em(cleanup_test_sessions):
+    """HTML <em> in list item renders as italic."""
+    out = render_md("- <em>emphasized</em> text")
+    assert "<em>emphasized</em>" in out
+    assert "&lt;em&gt;" not in out
+
+def test_list_html_b_tag(cleanup_test_sessions):
+    """HTML <b> in list item renders as bold."""
+    out = render_md("- <b>bold via b tag</b>")
+    assert "<strong>bold via b tag</strong>" in out
+    assert "&lt;b&gt;" not in out
+
+def test_list_html_i_tag(cleanup_test_sessions):
+    """HTML <i> in list item renders as italic."""
+    out = render_md("- <i>italic via i tag</i>")
+    assert "<em>italic via i tag</em>" in out
+    assert "&lt;i&gt;" not in out
+
+def test_list_multiple_items_each_formatted(cleanup_test_sessions):
+    """Multiple list items each with different formatting."""
+    out = render_md(
+        "- **bold item**\n"
+        "- *italic item*\n"
+        "- `code item`\n"
+        "- plain item"
+    )
+    assert "<strong>bold item</strong>" in out
+    assert "<em>italic item</em>" in out
+    assert "<code>code item</code>" in out
+    assert "<li>plain item</li>" in out
+
+def test_list_item_bold_mid_sentence(cleanup_test_sessions):
+    """Bold in middle of a list item sentence."""
+    out = render_md("- Set the **timeout** to 30 seconds")
+    assert "<strong>timeout</strong>" in out
+    assert "Set the" in out
+    assert "to 30 seconds" in out
+
+def test_list_item_multiple_bold_spans(cleanup_test_sessions):
+    """Multiple bold spans in one list item."""
+    out = render_md("- **A** and **B** are both important")
+    assert "<strong>A</strong>" in out
+    assert "<strong>B</strong>" in out
+
+def test_ordered_list_bold(cleanup_test_sessions):
+    """Bold text inside ordered list items."""
+    out = render_md("1. **First** step\n2. **Second** step\n3. Plain step")
+    assert "<ol>" in out
+    assert "<strong>First</strong>" in out
+    assert "<strong>Second</strong>" in out
+    assert "<li>Plain step</li>" in out
+
+def test_ordered_list_html_strong(cleanup_test_sessions):
+    """HTML <strong> inside ordered list items renders correctly."""
+    out = render_md("1. <strong>Install</strong> the package\n2. <strong>Configure</strong> the settings")
+    assert "<ol>" in out
+    assert "<strong>Install</strong>" in out
+    assert "<strong>Configure</strong>" in out
+    assert "&lt;strong&gt;" not in out
+
+def test_ordered_list_code_spans(cleanup_test_sessions):
+    """Code spans inside ordered list items."""
+    out = render_md("1. Run `npm install`\n2. Run `npm start`")
+    assert "<code>npm install</code>" in out
+    assert "<code>npm start</code>" in out
+
+def test_indented_list_item_bold(cleanup_test_sessions):
+    """Bold inside indented (nested) list item."""
+    out = render_md("- top level\n  - **nested bold**")
+    assert "<strong>nested bold</strong>" in out
+    assert "margin-left:16px" in out
+
+# --- Blockquote variants ---
+
+def test_blockquote_plain(cleanup_test_sessions):
+    """Plain blockquote wraps in <blockquote>."""
+    out = render_md("> simple quote")
+    assert "<blockquote>simple quote</blockquote>" in out
+
+def test_blockquote_bold(cleanup_test_sessions):
+    """**bold** inside blockquote renders correctly."""
+    out = render_md("> **important** note")
+    assert "<strong>important</strong>" in out
+
+def test_blockquote_html_strong(cleanup_test_sessions):
+    """<strong> inside blockquote renders as bold."""
+    out = render_md("> <strong>Warning:</strong> read this")
+    assert "<strong>Warning:</strong>" in out
+    assert "&lt;strong&gt;" not in out
+
+def test_blockquote_code_span(cleanup_test_sessions):
+    """Code span inside blockquote renders correctly."""
+    out = render_md("> Use `git commit` to save")
+    assert "<code>git commit</code>" in out
+
+def test_blockquote_mixed_formatting(cleanup_test_sessions):
+    """Mixed bold and code in blockquote."""
+    out = render_md("> **Note:** run `pip install foo` first")
+    assert "<strong>Note:</strong>" in out
+    assert "<code>pip install foo</code>" in out
+
+def test_blockquote_xss_blocked(cleanup_test_sessions):
+    """XSS in blockquote content must be escaped."""
+    out = render_md("> <img src=x onerror=alert(1)>")
+    assert "&lt;img" in out
+    assert "<img" not in out
+
+# --- Heading variants ---
+
+def test_heading_h1_bold(cleanup_test_sessions):
+    """Bold inside h1 renders correctly."""
+    out = render_md("# **Main** Title")
+    assert "<h1><strong>Main</strong> Title</h1>" in out
+
+def test_heading_h2_html_strong(cleanup_test_sessions):
+    """HTML <strong> inside h2 renders correctly."""
+    out = render_md("## <strong>Section</strong> Name")
+    assert "<h2><strong>Section</strong> Name</h2>" in out
+    assert "&lt;strong&gt;" not in out
+
+def test_heading_h3_code(cleanup_test_sessions):
+    """Code span inside h3 renders correctly."""
+    out = render_md("### The `renderMd` function")
+    assert "<h3>The <code>renderMd</code> function</h3>" in out
+
+def test_heading_xss_blocked(cleanup_test_sessions):
+    """XSS attempt in heading must be escaped."""
+    out = render_md("## <script>alert(1)</script>")
+    assert "<script>" not in out
+    assert "&lt;script" in out
+
+# --- Paragraph / top-level formatting ---
+
+def test_paragraph_bold_renders(cleanup_test_sessions):
+    """Bold in a plain paragraph renders correctly."""
+    out = render_md("The **quick brown fox** jumps.")
+    assert "<strong>quick brown fox</strong>" in out
+
+def test_paragraph_html_strong_renders(cleanup_test_sessions):
+    """HTML <strong> in a plain paragraph renders correctly."""
+    out = render_md("The <strong>quick brown fox</strong> jumps.")
+    assert "<strong>quick brown fox</strong>" in out
+    assert "&lt;strong&gt;" not in out
+
+def test_paragraph_html_code_renders(cleanup_test_sessions):
+    """HTML <code> in a plain paragraph renders correctly."""
+    out = render_md("Call <code>foo()</code> to start.")
+    assert "<code>foo()</code>" in out
+    assert "&lt;code&gt;" not in out
+
+def test_paragraph_br_creates_line_break(cleanup_test_sessions):
+    """<br> in paragraph becomes a line break inside <p>."""
+    out = render_md("Line one<br>Line two")
+    # br converts to \n which inside <p> becomes <br>
+    assert "Line one" in out and "Line two" in out
+
+def test_multiple_paragraphs_separated(cleanup_test_sessions):
+    """Double newline creates separate <p> elements."""
+    out = render_md("First paragraph.\n\nSecond paragraph.")
+    assert out.count("<p>") == 2
+
+# --- Table variants ---
+
+def test_table_structure_in_ui_js(cleanup_test_sessions):
+    """ui.js must contain table rendering logic with thead/tbody structure."""
+    src = (REPO_ROOT / "static" / "ui.js").read_text()
+    assert "<table>" in src or "table>" in src, "table rendering not found in ui.js"
+    assert "thead" in src, "thead not found in table renderer"
+    assert "tbody" in src, "tbody not found in table renderer"
+    assert "parseRow" in src, "parseRow helper not found in table renderer"
+
+# --- br tag specifically ---
+
+def test_br_in_list_item(cleanup_test_sessions):
+    """<br> inside a list item becomes a newline."""
+    out = render_md("- Line one<br>Line two")
+    assert "Line one" in out
+    assert "Line two" in out
+
+def test_br_self_closing_in_paragraph(cleanup_test_sessions):
+    """<br/> self-closing form is also handled."""
+    out = render_md("Before<br/>After")
+    assert "Before" in out and "After" in out
+
+# --- No double-escaping ---
+
+def test_no_double_escaping_ampersand(cleanup_test_sessions):
+    """A literal & in text must become &amp; exactly once, not &amp;amp;."""
+    out = render_md("foo & bar")
+    assert "&amp;amp;" not in out
+    assert "&amp;" in out or "foo & bar" in out  # either fine (paragraph wrap may not escape)
+
+def test_no_double_escaping_lt_in_code(cleanup_test_sessions):
+    """< inside a code span must become &lt; exactly once."""
+    out = render_md("`a < b`")
+    assert "&lt;lt;" not in out
+    assert "&lt;" in out
+
+def test_strong_text_not_double_escaped(cleanup_test_sessions):
+    """Content of <strong> must not be double-escaped."""
+    out = render_md("<strong>hello & world</strong>")
+    # The & inside strong content should be escaped once
+    assert "&amp;amp;" not in out
+    assert "<strong>" in out
+
+# --- inlineMd helper present in source ---
+
+def test_inline_md_helper_in_ui_js(cleanup_test_sessions):
+    """ui.js must define inlineMd() helper function."""
+    src = (REPO_ROOT / "static" / "ui.js").read_text()
+    assert "function inlineMd(" in src, "inlineMd() helper not found in ui.js"
+
+def test_inline_md_used_in_list_handler(cleanup_test_sessions):
+    """List handler in ui.js must call inlineMd() not esc() for item text."""
+    src = (REPO_ROOT / "static" / "ui.js").read_text()
+    # Find the list block handler
+    ul_idx = src.find("html+='<ul>'") or src.find('html+=`<ul>`') or src.find("let html='<ul>'")
+    assert ul_idx >= 0 or "inlineMd(text)" in src, "inlineMd not called in list handler"
+    # Verify inlineMd is called, not bare esc
+    assert "inlineMd(text)" in src, "inlineMd(text) call not found — list items may not render formatting"
+
+def test_inline_md_used_in_blockquote_handler(cleanup_test_sessions):
+    """Blockquote handler in ui.js must call inlineMd() not esc() for content."""
+    src = (REPO_ROOT / "static" / "ui.js").read_text()
+    assert "inlineMd(t)" in src, "inlineMd not called in blockquote/heading handler"
+
+
+def test_sessions_js_has_svg_icons(cleanup_test_sessions):
+    """sessions.js must define ICONS object with SVG strings for sidebar buttons."""
+    src = REPO_ROOT / "static" / "sessions.js"
+    code = src.read_text()
+    assert "const ICONS=" in code or "const ICONS =" in code, "ICONS constant not found"
+    for icon in ["pin", "folder", "archive", "trash", "dup"]:
+        assert icon + ":" in code or f"'{icon}'" in code, f"ICONS.{icon} not found"
+    assert "<svg" in code, "SVG content not found in ICONS"
+
+
+def test_sessions_js_has_overlay_actions(cleanup_test_sessions):
+    """sessions.js must use .session-actions overlay div for action buttons."""
+    src = REPO_ROOT / "static" / "sessions.js"
+    code = src.read_text()
+    assert "session-actions" in code, ".session-actions overlay not found in sessions.js"
+
+
+def test_style_css_has_session_actions_overlay(cleanup_test_sessions):
+    """style.css must define .session-actions with position:absolute."""
+    src = REPO_ROOT / "static" / "style.css"
+    code = src.read_text()
+    assert ".session-actions" in code, ".session-actions not found in style.css"
+    assert "position:absolute" in code or "position: absolute" in code, \
+        ".session-actions must use position:absolute for overlay"
+
+
+def test_style_css_active_session_uses_gold(cleanup_test_sessions):
+    """Active session style should use gold/amber color (#e8a030) not just blue."""
+    src = REPO_ROOT / "static" / "style.css"
+    code = src.read_text()
+    assert "#e8a030" in code, \
+        "Active session gold color (#e8a030) not found in style.css"
+
+
+def test_sessions_js_active_skips_project_border(cleanup_test_sessions):
+    """sessions.js must not override active session border-left with project color."""
+    src = REPO_ROOT / "static" / "sessions.js"
+    code = src.read_text()
+    # The fix: only set borderLeftColor if NOT the active session
+    assert "isActive" in code, "isActive check not found in sessions.js"
+    assert "borderLeftColor" in code, "borderLeftColor not found in sessions.js"

tests/test_sprint17.py

@@ -0,0 +1,96 @@
+"""
+Sprint 17 Tests: send_key setting, commands.js static file, workspace subdir listing.
+"""
+import json, urllib.error, urllib.request
+
+BASE = "http://127.0.0.1:8788"
+
+
+def get(path):
+    with urllib.request.urlopen(BASE + path, timeout=10) as r:
+        return json.loads(r.read()), r.status
+
+
+def post(path, body=None):
+    data = json.dumps(body or {}).encode()
+    req = urllib.request.Request(BASE + path, data=data,
+                                headers={"Content-Type": "application/json"})
+    try:
+        with urllib.request.urlopen(req, timeout=10) as r:
+            return json.loads(r.read()), r.status
+    except urllib.error.HTTPError as e:
+        return json.loads(e.read()), e.code
+
+
+def make_session(created_list):
+    d, _ = post("/api/session/new", {})
+    sid = d["session"]["session_id"]
+    created_list.append(sid)
+    return sid, d["session"]
+
+
+# ── Settings: send_key ──────────────────────────────────────────────────────
+
+def test_settings_send_key_default():
+    """GET /api/settings returns send_key with default value 'enter'."""
+    data, status = get("/api/settings")
+    assert status == 200
+    assert data.get("send_key") == "enter"
+
+
+def test_settings_save_send_key():
+    """POST /api/settings with send_key persists and round-trips."""
+    try:
+        # Save ctrl+enter
+        _, status = post("/api/settings", {"send_key": "ctrl+enter"})
+        assert status == 200
+        # Verify it persisted
+        data, _ = get("/api/settings")
+        assert data["send_key"] == "ctrl+enter"
+    finally:
+        # Always restore default
+        post("/api/settings", {"send_key": "enter"})
+    data, _ = get("/api/settings")
+    assert data["send_key"] == "enter"
+
+
+def test_settings_invalid_send_key_rejected():
+    """POST /api/settings with invalid send_key value is silently ignored."""
+    # Set a known good value first
+    post("/api/settings", {"send_key": "enter"})
+    # Try to set an invalid value
+    data, status = post("/api/settings", {"send_key": "invalid_value"})
+    assert status == 200
+    # Should still be 'enter' (invalid value ignored)
+    assert data["send_key"] == "enter"
+
+
+def test_settings_unknown_key_ignored():
+    """POST /api/settings ignores unknown keys."""
+    data, status = post("/api/settings", {"unknown_key": "value", "send_key": "enter"})
+    assert status == 200
+    assert "unknown_key" not in data
+
+
+# ── Static file: commands.js ────────────────────────────────────────────────
+
+def test_static_commands_js_served():
+    """GET /static/commands.js returns 200 and contains COMMANDS registry."""
+    req = urllib.request.Request(BASE + "/static/commands.js")
+    with urllib.request.urlopen(req, timeout=10) as r:
+        body = r.read().decode()
+        assert r.status == 200
+        assert "COMMANDS" in body
+        assert "executeCommand" in body
+
+
+# ── Workspace: subdir listing ───────────────────────────────────────────────
+
+def test_list_workspace_root():
+    """GET /api/list with path=. returns entries for workspace root."""
+    created = []
+    sid, _ = make_session(created)
+    data, status = get(f"/api/list?session_id={sid}&path=.")
+    assert status == 200
+    assert "entries" in data
+    assert isinstance(data["entries"], list)

tests/test_sprint19.py

@@ -0,0 +1,118 @@
+"""
+Sprint 19 Tests: auth/login, security headers, request size limit.
+"""
+import json, urllib.error, urllib.request
+
+BASE = "http://127.0.0.1:8788"
+
+
+def get(path, headers=None):
+    req = urllib.request.Request(BASE + path)
+    if headers:
+        for k, v in headers.items():
+            req.add_header(k, v)
+    with urllib.request.urlopen(req, timeout=10) as r:
+        return json.loads(r.read()), r.status, dict(r.headers)
+
+
+def post(path, body=None, headers=None):
+    data = json.dumps(body or {}).encode()
+    req = urllib.request.Request(BASE + path, data=data,
+                                headers={"Content-Type": "application/json"})
+    if headers:
+        for k, v in headers.items():
+            req.add_header(k, v)
+    try:
+        with urllib.request.urlopen(req, timeout=10) as r:
+            return json.loads(r.read()), r.status, dict(r.headers)
+    except urllib.error.HTTPError as e:
+        return json.loads(e.read()), e.code, dict(e.headers)
+
+
+# ── Auth status (no password configured in test env) ──────────────────────
+
+def test_auth_status_disabled():
+    """Auth should be disabled by default (no password set)."""
+    d, status, _ = get("/api/auth/status")
+    assert status == 200
+    assert d["auth_enabled"] is False
+
+
+def test_login_when_auth_disabled():
+    """Login should succeed trivially when auth is not enabled."""
+    d, status, _ = post("/api/auth/login", {"password": "anything"})
+    assert status == 200
+    assert d["ok"] is True
+
+
+def test_all_routes_accessible_without_auth():
+    """When auth is disabled, all routes should work without cookies."""
+    d, status, _ = get("/api/sessions")
+    assert status == 200
+    assert "sessions" in d
+
+
+def test_login_page_served():
+    """GET /login should return the login page HTML."""
+    req = urllib.request.Request(BASE + "/login")
+    with urllib.request.urlopen(req, timeout=10) as r:
+        html = r.read().decode()
+        assert r.status == 200
+        assert "Sign in" in html
+        assert "Hermes" in html
+
+
+# ── Security headers ─────────────────────────────────────────────────────
+
+def test_security_headers_on_json():
+    """JSON responses should include security headers."""
+    d, status, headers = get("/api/auth/status")
+    assert status == 200
+    assert headers.get("X-Content-Type-Options") == "nosniff"
+    assert headers.get("X-Frame-Options") == "DENY"
+    assert headers.get("Referrer-Policy") == "same-origin"
+
+
+def test_security_headers_on_health():
+    """Health endpoint should include security headers."""
+    d, status, headers = get("/health")
+    assert status == 200
+    assert headers.get("X-Content-Type-Options") == "nosniff"
+
+
+def test_cache_control_no_store():
+    """API responses should have Cache-Control: no-store."""
+    d, status, headers = get("/api/sessions")
+    assert headers.get("Cache-Control") == "no-store"
+
+
+# ── Settings password field ──────────────────────────────────────────────
+
+def test_settings_password_hash_not_exposed():
+    """GET /api/settings must never expose the stored password hash."""
+    d, status, _ = get("/api/settings")
+    assert status == 200
+    assert "password_hash" not in d  # security: never send hash to client
+
+
+def test_settings_save_preserves_other_fields():
+    """Saving settings should not break existing fields."""
+    # Get current settings
+    current, _, _ = get("/api/settings")
+    # Save with just send_key
+    d, status, _ = post("/api/settings", {"send_key": "enter"})
+    assert status == 200
+    # Verify other fields still present
+    updated, _, _ = get("/api/settings")
+    assert "default_model" in updated
+    assert "default_workspace" in updated
+
+
+def test_settings_password_hash_not_directly_settable():
+    """POST /api/settings with password_hash must not overwrite the stored hash."""
+    # Attempt to set a raw hash directly (attack vector)
+    post("/api/settings", {"password_hash": "deadbeef" * 8})
+    # Settings response must not expose it regardless
+    updated, status, _ = get("/api/settings")
+    assert status == 200
+    assert "password_hash" not in updated

tests/test_sprint20.py

@@ -0,0 +1,422 @@
+"""
+Sprint 20 Tests: Voice input (mic button) via Web Speech API.
+
+These tests verify the static assets contain the correct HTML structure,
+CSS rules, and JS logic for the mic feature — all of which runs purely in
+the browser with no server-side component.
+"""
+import re
+import urllib.request
+import json
+
+BASE = "http://127.0.0.1:8788"
+
+
+def get_text(path):
+    with urllib.request.urlopen(BASE + path, timeout=10) as r:
+        return r.read().decode(), r.status
+
+
+# ── index.html ────────────────────────────────────────────────────────────
+
+
+def test_mic_button_present_in_html():
+    """index.html must contain the mic button with id='btnMic'."""
+    html, status = get_text("/")
+    assert status == 200
+    assert 'id="btnMic"' in html
+
+
+def test_mic_button_has_mic_btn_class():
+    """btnMic must carry the mic-btn CSS class for styling hooks."""
+    html, _ = get_text("/")
+    assert 'class="icon-btn mic-btn"' in html
+
+
+def test_mic_button_hidden_by_default():
+    """btnMic starts hidden (display:none) — JS shows it only if supported."""
+    html, _ = get_text("/")
+    # The button element should have display:none in its style attribute
+    assert 'id="btnMic"' in html
+    btn_match = re.search(r'id="btnMic"[^>]*>', html)
+    assert btn_match, "btnMic element not found"
+    assert 'display:none' in btn_match.group(0)
+
+
+def test_mic_button_has_title():
+    """btnMic should have a descriptive title for accessibility."""
+    html, _ = get_text("/")
+    btn_match = re.search(r'id="btnMic"[^>]*>', html)
+    assert btn_match
+    assert 'title=' in btn_match.group(0)
+
+
+def test_mic_status_div_present():
+    """index.html must contain the #micStatus listening indicator."""
+    html, _ = get_text("/")
+    assert 'id="micStatus"' in html
+
+
+def test_mic_status_hidden_by_default():
+    """#micStatus starts hidden — only shown during active recording."""
+    html, _ = get_text("/")
+    status_match = re.search(r'id="micStatus"[^>]*>', html)
+    assert status_match, "#micStatus element not found"
+    assert 'display:none' in status_match.group(0)
+
+
+def test_mic_status_has_mic_dot():
+    """#micStatus must contain a .mic-dot element for the pulse animation."""
+    html, _ = get_text("/")
+    # mic-dot should appear after micStatus
+    idx_status = html.find('id="micStatus"')
+    idx_dot = html.find('mic-dot', idx_status)
+    assert idx_status != -1 and idx_dot != -1
+    assert idx_dot > idx_status
+
+
+def test_mic_status_has_listening_text():
+    """#micStatus should display a 'Listening' label."""
+    html, _ = get_text("/")
+    assert 'Listening' in html
+
+
+def test_mic_button_svg_microphone_shape():
+    """btnMic SVG must include the rect (mic body) and path (mic arc)."""
+    html, _ = get_text("/")
+    # Find mic button section
+    btn_start = html.find('id="btnMic"')
+    btn_end = html.find('</button>', btn_start) + len('</button>')
+    btn_html = html[btn_start:btn_end]
+    assert '<rect' in btn_html, "mic SVG missing rect (mic body)"
+    assert '<path' in btn_html, "mic SVG missing path (arc)"
+    assert '<line' in btn_html, "mic SVG missing line (stand)"
+
+
+def test_mic_button_inside_composer_left():
+    """btnMic must be inside .composer-left, next to the attach button."""
+    html, _ = get_text("/")
+    composer_left_start = html.find('class="composer-left"')
+    composer_left_end = html.find('</div>', composer_left_start)
+    section = html[composer_left_start:composer_left_end]
+    assert 'btnAttach' in section
+    assert 'btnMic' in section
+
+
+# ── style.css ────────────────────────────────────────────────────────────
+
+
+def test_mic_btn_css_rule_exists():
+    """style.css must define .mic-btn rule."""
+    css, status = get_text("/static/style.css")
+    assert status == 200
+    assert '.mic-btn' in css
+
+
+def test_mic_btn_recording_state_css():
+    """.mic-btn.recording must be defined for active recording visual state."""
+    css, _ = get_text("/static/style.css")
+    assert '.mic-btn.recording' in css
+
+
+def test_mic_recording_color_red():
+    """.mic-btn.recording must use the red accent color #e94560."""
+    css, _ = get_text("/static/style.css")
+    recording_idx = css.find('.mic-btn.recording')
+    # Find the rule block after the selector
+    brace_open = css.find('{', recording_idx)
+    brace_close = css.find('}', brace_open)
+    rule = css[brace_open:brace_close]
+    assert '#e94560' in rule or 'e94560' in rule
+
+
+def test_mic_recording_has_animation():
+    """.mic-btn.recording must use an animation for the pulse effect."""
+    css, _ = get_text("/static/style.css")
+    recording_idx = css.find('.mic-btn.recording')
+    brace_open = css.find('{', recording_idx)
+    brace_close = css.find('}', brace_open)
+    rule = css[brace_open:brace_close]
+    assert 'animation' in rule
+
+
+def test_mic_pulse_keyframes_defined():
+    """@keyframes mic-pulse must be defined for the pulsing animation."""
+    css, _ = get_text("/static/style.css")
+    assert 'mic-pulse' in css
+    assert '@keyframes' in css
+
+
+def test_mic_status_css_rule_exists():
+    """style.css must define .mic-status rule."""
+    css, _ = get_text("/static/style.css")
+    assert '.mic-status' in css
+
+
+def test_mic_dot_css_rule_exists():
+    """style.css must define .mic-dot rule with animation."""
+    css, _ = get_text("/static/style.css")
+    assert '.mic-dot' in css
+    dot_idx = css.find('.mic-dot')
+    brace_open = css.find('{', dot_idx)
+    brace_close = css.find('}', brace_open)
+    rule = css[brace_open:brace_close]
+    assert 'animation' in rule
+
+
+def test_mic_btn_has_transition():
+    """.mic-btn must define a transition for smooth state changes."""
+    css, _ = get_text("/static/style.css")
+    mic_btn_idx = css.find('.mic-btn{')
+    if mic_btn_idx == -1:
+        mic_btn_idx = css.find('.mic-btn ')
+    brace_open = css.find('{', mic_btn_idx)
+    brace_close = css.find('}', brace_open)
+    rule = css[brace_open:brace_close]
+    assert 'transition' in rule
+
+
+# ── boot.js ──────────────────────────────────────────────────────────────
+
+
+def test_boot_js_serves_ok():
+    """boot.js must be served successfully."""
+    _, status = get_text("/static/boot.js")
+    assert status == 200
+
+
+def test_boot_js_speech_recognition_check():
+    """boot.js must check for SpeechRecognition (with webkit fallback)."""
+    js, _ = get_text("/static/boot.js")
+    assert 'SpeechRecognition' in js
+    assert 'webkitSpeechRecognition' in js
+
+
+def test_boot_js_recognition_config():
+    """boot.js must configure recognition.continuous, interimResults, and lang."""
+    js, _ = get_text("/static/boot.js")
+    assert 'recognition.continuous' in js
+    assert 'recognition.interimResults' in js
+    assert 'recognition.lang' in js
+
+
+def test_boot_js_recognition_not_continuous():
+    """recognition.continuous must be false (auto-stop after silence)."""
+    js, _ = get_text("/static/boot.js")
+    assert 'recognition.continuous=false' in js or 'recognition.continuous = false' in js
+
+
+def test_boot_js_recognition_interim_results():
+    """recognition.interimResults must be true (live transcription preview)."""
+    js, _ = get_text("/static/boot.js")
+    assert 'recognition.interimResults=true' in js or 'recognition.interimResults = true' in js
+
+
+def test_boot_js_recognition_lang_en():
+    """recognition.lang must be set to en-US."""
+    js, _ = get_text("/static/boot.js")
+    assert "recognition.lang='en-US'" in js or 'recognition.lang = "en-US"' in js or "recognition.lang='en-US'" in js
+
+
+def test_boot_js_onresult_handler():
+    """boot.js must define recognition.onresult to handle transcription."""
+    js, _ = get_text("/static/boot.js")
+    assert 'recognition.onresult' in js
+
+
+def test_boot_js_onend_handler():
+    """boot.js must define recognition.onend to reset state when recording stops."""
+    js, _ = get_text("/static/boot.js")
+    assert 'recognition.onend' in js
+
+
+def test_boot_js_onerror_handler():
+    """boot.js must define recognition.onerror for graceful error handling."""
+    js, _ = get_text("/static/boot.js")
+    assert 'recognition.onerror' in js
+
+
+def test_boot_js_not_allowed_error_message():
+    """onerror must handle 'not-allowed' with a user-friendly message."""
+    js, _ = get_text("/static/boot.js")
+    assert 'not-allowed' in js
+    assert 'permission' in js.lower() or 'denied' in js.lower() or 'access' in js.lower()
+
+
+def test_boot_js_no_speech_error_message():
+    """onerror must handle 'no-speech' with a user-friendly message."""
+    js, _ = get_text("/static/boot.js")
+    assert 'no-speech' in js
+
+
+def test_boot_js_network_error_message():
+    """onerror must handle 'network' error."""
+    js, _ = get_text("/static/boot.js")
+    assert "'network'" in js or '"network"' in js
+
+
+def test_boot_js_mic_active_flag():
+    """boot.js must track recording state via _micActive flag."""
+    js, _ = get_text("/static/boot.js")
+    assert '_micActive' in js
+
+
+def test_boot_js_mic_recording_class_toggle():
+    """boot.js must toggle 'recording' CSS class on the mic button."""
+    js, _ = get_text("/static/boot.js")
+    assert "'recording'" in js or '"recording"' in js
+
+
+def test_boot_js_mic_status_toggle():
+    """boot.js must show/hide #micStatus during recording."""
+    js, _ = get_text("/static/boot.js")
+    assert 'micStatus' in js
+
+
+def test_boot_js_send_stops_mic():
+    """btnSend onclick must stop mic before sending (send guard)."""
+    js, _ = get_text("/static/boot.js")
+    # The send button onclick should check _micActive and stop recording
+    send_onclick_idx = js.find("$('btnSend').onclick")
+    assert send_onclick_idx != -1
+    # Find the handler code — check that _micActive check appears near send assignment
+    handler_end = js.find(';', send_onclick_idx)
+    handler = js[send_onclick_idx:handler_end + 1]
+    assert '_micActive' in handler or 'stopMic' in handler.lower()
+
+
+def test_boot_js_btn_mic_onclick():
+    """boot.js must attach an onclick handler to btnMic."""
+    js, _ = get_text("/static/boot.js")
+    assert 'btn.onclick' in js or "btnMic.onclick" in js or "$('btnMic').onclick" in js
+
+
+def test_boot_js_recognition_start():
+    """boot.js must call recognition.start() to begin recording."""
+    js, _ = get_text("/static/boot.js")
+    assert 'recognition.start()' in js
+
+
+def test_boot_js_recognition_stop():
+    """boot.js must call recognition.stop() to end recording."""
+    js, _ = get_text("/static/boot.js")
+    assert 'recognition.stop()' in js
+
+
+def test_boot_js_iife_guard():
+    """Mic logic must be wrapped in an IIFE so it doesn't pollute global scope."""
+    js, _ = get_text("/static/boot.js")
+    # IIFE pattern: (function(){...})() or (() => {...})()
+    assert '(function(){' in js or '(function () {' in js
+
+
+def test_boot_js_browser_unsupported_return():
+    """boot.js must bail out (return) early when SpeechRecognition is unavailable."""
+    js, _ = get_text("/static/boot.js")
+    # The IIFE should have an early return when SpeechRecognition is falsy
+    assert 'if(!SpeechRecognition)' in js or 'if (!SpeechRecognition)' in js
+
+
+def test_boot_js_shows_mic_button_when_supported():
+    """boot.js must set display='' on btnMic when SpeechRecognition is available."""
+    js, _ = get_text("/static/boot.js")
+    assert "btn.style.display=''" in js or 'btn.style.display = ""' in js
+
+
+def test_boot_js_show_toast_on_error():
+    """boot.js must call showToast() for mic errors."""
+    js, _ = get_text("/static/boot.js")
+    assert 'showToast' in js
+
+
+def test_boot_js_autoresize_called():
+    """boot.js must call autoResize() after updating textarea from transcript."""
+    js, _ = get_text("/static/boot.js")
+    assert 'autoResize()' in js
+
+
+# ── Append behaviour (fix: mic appends to existing text, not replace) ────
+
+
+def test_boot_js_prefix_variable_declared():
+    """boot.js must declare _prefix variable to snapshot pre-existing textarea content."""
+    js, _ = get_text("/static/boot.js")
+    assert "_prefix" in js
+
+
+def test_boot_js_prefix_captured_on_start():
+    """_prefix must be set from ta.value when the user starts recording."""
+    js, _ = get_text("/static/boot.js")
+    # _prefix assignment must happen in the btn.onclick else branch (before recognition.start)
+    btn_onclick_idx = js.find("btn.onclick")
+    btn_onclick_end = js.find("};", btn_onclick_idx)
+    onclick_body = js[btn_onclick_idx:btn_onclick_end]
+    assert "_prefix=ta.value" in onclick_body or "_prefix = ta.value" in onclick_body
+
+
+def test_boot_js_onresult_prepends_prefix():
+    """onresult must include _prefix when writing to textarea (append, not replace)."""
+    js, _ = get_text("/static/boot.js")
+    onresult_idx = js.find("recognition.onresult")
+    onresult_end = js.find("};", onresult_idx)
+    onresult_body = js[onresult_idx:onresult_end]
+    # ta.value must be set to _prefix + something, not just the transcript alone
+    assert "_prefix" in onresult_body
+
+
+def test_boot_js_onend_commits_with_prefix():
+    """onend must commit _prefix + _finalText so appended text survives after recognition ends."""
+    js, _ = get_text("/static/boot.js")
+    onend_idx = js.find("recognition.onend")
+    onend_end = js.find("};", onend_idx)
+    onend_body = js[onend_idx:onend_end]
+    assert "_prefix" in onend_body
+
+
+def test_boot_js_prefix_reset_on_stop():
+    """_prefix must be reset when recording stops so next session starts clean."""
+    js, _ = get_text("/static/boot.js")
+    # _setRecording(false) clears both _finalText and _prefix
+    set_rec_idx = js.find("function _setRecording")
+    set_rec_end = js.find("}", set_rec_idx) + 1
+    fn_body = js[set_rec_idx:set_rec_end]
+    assert "_prefix" in fn_body
+
+
+def test_boot_js_auto_space_between_prefix_and_transcript():
+    """onend must insert a space between existing text and new transcript when needed."""
+    js, _ = get_text("/static/boot.js")
+    onend_idx = js.find("recognition.onend")
+    onend_end = js.find("};", onend_idx)
+    onend_body = js[onend_idx:onend_end]
+    # Should handle spacing — look for trimStart or endsWith(' ') check
+    has_spacing = ("trimStart" in onend_body or "endsWith(' ')" in onend_body
+                   or "endsWith(\" \")" in onend_body or "endsWith('\\n')" in onend_body)
+    assert has_spacing, "onend should handle spacing between prefix and new transcript"
+
+
+# ── Regression: existing behaviour unchanged ──────────────────────────────
+
+
+def test_attach_button_still_wired():
+    """btnAttach onclick must still be wired up (no regression)."""
+    js, _ = get_text("/static/boot.js")
+    assert "$('btnAttach').onclick" in js
+
+
+def test_file_input_onchange_still_wired():
+    """fileInput onchange must still be wired up (no regression)."""
+    js, _ = get_text("/static/boot.js")
+    assert "$('fileInput').onchange" in js
+
+
+def test_index_html_still_has_send_button():
+    """btnSend must still be present in index.html (no regression)."""
+    html, _ = get_text("/")
+    assert 'id="btnSend"' in html
+
+
+def test_index_html_still_has_attach_button():
+    """btnAttach must still be present in index.html (no regression)."""
+    html, _ = get_text("/")
+    assert 'id="btnAttach"' in html

tests/test_sprint20b.py

@@ -0,0 +1,343 @@
+"""
+Sprint 21 Tests: Send button polish — hidden until content, pop-in animation,
+icon-only circle design.
+"""
+import re
+import urllib.request
+
+BASE = "http://127.0.0.1:8788"
+
+
+def get_text(path):
+    with urllib.request.urlopen(BASE + path, timeout=10) as r:
+        return r.read().decode(), r.status
+
+
+# ── index.html ────────────────────────────────────────────────────────────
+
+
+def test_send_button_present():
+    """btnSend must still exist in the DOM."""
+    html, status = get_text("/")
+    assert status == 200
+    assert 'id="btnSend"' in html
+
+
+def test_send_button_hidden_by_default():
+    """btnSend must start hidden (display:none) — only shown when there is content."""
+    html, _ = get_text("/")
+    btn_match = re.search(r'id="btnSend"[^>]*>', html)
+    assert btn_match, "btnSend element not found"
+    assert 'display:none' in btn_match.group(0)
+
+
+def test_send_button_no_text_label():
+    """Send button must be icon-only — no visible 'Send' text label."""
+    html, _ = get_text("/")
+    # Find the full button element (from opening tag to closing tag)
+    btn_open_end = html.find('>', html.find('id="btnSend"')) + 1
+    btn_end = html.find('</button>', btn_open_end) + len('</button>')
+    btn_inner = html[btn_open_end:btn_end]
+    # Strip SVG content and any remaining tags; check visible text
+    no_svg = re.sub(r'<svg[^>]*>.*?</svg>', '', btn_inner, flags=re.DOTALL)
+    visible_text = re.sub(r'<[^>]+>', '', no_svg).strip()
+    assert visible_text == '', f"Send button has visible text: {visible_text!r}"
+
+
+def test_send_button_has_svg_icon():
+    """Send button must have an SVG icon."""
+    html, _ = get_text("/")
+    btn_start = html.find('id="btnSend"')
+    btn_end = html.find('</button>', btn_start) + len('</button>')
+    btn_html = html[btn_start:btn_end]
+    assert '<svg' in btn_html
+
+
+def test_send_button_has_title_attribute():
+    """btnSend must have a title attribute for accessibility (replaces text label)."""
+    html, _ = get_text("/")
+    btn_match = re.search(r'id="btnSend"[^>]*>', html)
+    assert btn_match
+    assert 'title=' in btn_match.group(0)
+
+
+def test_send_button_svg_arrow_up():
+    """Send button SVG should use an upward arrow (line + polyline or path)."""
+    html, _ = get_text("/")
+    btn_start = html.find('id="btnSend"')
+    btn_end = html.find('</button>', btn_start) + len('</button>')
+    btn_html = html[btn_start:btn_end]
+    # Must have some directional shape element
+    has_shape = ('<line' in btn_html or '<polyline' in btn_html or
+                 '<polygon' in btn_html or '<path' in btn_html)
+    assert has_shape, "Send button SVG missing directional shape"
+
+
+# ── style.css ────────────────────────────────────────────────────────────
+
+
+def test_send_btn_is_circle():
+    """send-btn must use border-radius:50% for the circle shape."""
+    css, status = get_text("/static/style.css")
+    assert status == 200
+    send_idx = css.find('.send-btn{')
+    brace_open = css.find('{', send_idx)
+    brace_close = css.find('}', brace_open)
+    rule = css[brace_open:brace_close]
+    assert 'border-radius:50%' in rule or 'border-radius: 50%' in rule
+
+
+def test_send_btn_fixed_dimensions():
+    """send-btn must have explicit width and height (icon-circle, not text-padded)."""
+    css, _ = get_text("/static/style.css")
+    send_idx = css.find('.send-btn{')
+    brace_open = css.find('{', send_idx)
+    brace_close = css.find('}', brace_open)
+    rule = css[brace_open:brace_close]
+    assert 'width:' in rule or 'width :' in rule
+    assert 'height:' in rule or 'height :' in rule
+
+
+def test_send_btn_no_old_padding():
+    """send-btn must not use text padding layout (old pill style removed)."""
+    css, _ = get_text("/static/style.css")
+    send_idx = css.find('.send-btn{')
+    brace_open = css.find('{', send_idx)
+    brace_close = css.find('}', brace_open)
+    rule = css[brace_open:brace_close]
+    # Old style used padding:7px 18px — should be gone
+    assert 'padding:7px' not in rule and 'padding: 7px' not in rule
+
+
+def test_send_btn_blue_background():
+    """send-btn background must use the blue accent (#7cb9ff or similar)."""
+    css, _ = get_text("/static/style.css")
+    send_idx = css.find('.send-btn{')
+    brace_open = css.find('{', send_idx)
+    brace_close = css.find('}', brace_open)
+    rule = css[brace_open:brace_close]
+    assert '7cb9ff' in rule or '5ba8f5' in rule or 'var(--blue)' in rule
+
+
+def test_send_btn_has_transition():
+    """send-btn must have transition for smooth hover/active states."""
+    css, _ = get_text("/static/style.css")
+    send_idx = css.find('.send-btn{')
+    brace_open = css.find('{', send_idx)
+    brace_close = css.find('}', brace_open)
+    rule = css[brace_open:brace_close]
+    assert 'transition' in rule
+
+
+def test_send_btn_has_box_shadow():
+    """send-btn must have a box-shadow glow effect."""
+    css, _ = get_text("/static/style.css")
+    send_idx = css.find('.send-btn{')
+    brace_open = css.find('{', send_idx)
+    brace_close = css.find('}', brace_open)
+    rule = css[brace_open:brace_close]
+    assert 'box-shadow' in rule
+
+
+def test_send_btn_hover_has_scale():
+    """send-btn:hover must use transform:scale for a satisfying hover effect."""
+    css, _ = get_text("/static/style.css")
+    hover_idx = css.find('.send-btn:hover{')
+    brace_open = css.find('{', hover_idx)
+    brace_close = css.find('}', brace_open)
+    rule = css[brace_open:brace_close]
+    assert 'scale' in rule
+
+
+def test_send_btn_active_shrinks():
+    """send-btn:active must scale down slightly for tactile press feedback."""
+    css, _ = get_text("/static/style.css")
+    active_idx = css.find('.send-btn:active{')
+    brace_open = css.find('{', active_idx)
+    brace_close = css.find('}', brace_open)
+    rule = css[brace_open:brace_close]
+    assert 'scale' in rule
+
+
+def test_send_btn_disabled_rule_exists():
+    """send-btn:disabled must still be styled."""
+    css, _ = get_text("/static/style.css")
+    assert '.send-btn:disabled' in css
+
+
+def test_send_btn_visible_class_defined():
+    """.send-btn.visible class must be defined for the pop-in animation."""
+    css, _ = get_text("/static/style.css")
+    assert '.send-btn.visible' in css
+
+
+def test_send_pop_in_keyframes_defined():
+    """@keyframes send-pop-in must be defined."""
+    css, _ = get_text("/static/style.css")
+    assert 'send-pop-in' in css
+    assert '@keyframes' in css
+
+
+def _extract_keyframe(css, name):
+    """Extract the full @keyframes block for the given animation name."""
+    # Find '@keyframes <name>' directly (forward search) to avoid hitting
+    # an earlier keyframe when multiple are defined on the same line.
+    kf_start = css.find('@keyframes ' + name)
+    assert kf_start != -1, f"@keyframes {name} not found in CSS"
+    depth = 0
+    kf_end = kf_start
+    for i, ch in enumerate(css[kf_start:], kf_start):
+        if ch == '{':
+            depth += 1
+        elif ch == '}':
+            depth -= 1
+            if depth == 0:
+                kf_end = i
+                break
+    return css[kf_start:kf_end]
+
+
+def test_send_pop_in_uses_scale():
+    """send-pop-in keyframe must animate from a scaled-down state."""
+    css, _ = get_text("/static/style.css")
+    kf_rule = _extract_keyframe(css, 'send-pop-in')
+    assert 'scale' in kf_rule
+
+
+def test_send_pop_in_uses_opacity():
+    """send-pop-in keyframe must fade in (opacity transition)."""
+    css, _ = get_text("/static/style.css")
+    kf_rule = _extract_keyframe(css, 'send-pop-in')
+    assert 'opacity' in kf_rule
+
+
+def test_send_btn_mobile_override_no_padding():
+    """Mobile override for send-btn must not add text padding (keeps circle shape)."""
+    css, _ = get_text("/static/style.css")
+    # Find the @media block
+    media_idx = css.find('@media')
+    send_mobile_idx = css.find('.send-btn', media_idx)
+    if send_mobile_idx == -1:
+        return  # No mobile override, fine
+    brace_open = css.find('{', send_mobile_idx)
+    brace_close = css.find('}', brace_open)
+    rule = css[brace_open:brace_close]
+    assert 'padding:' not in rule and 'font-size' not in rule
+
+
+# ── ui.js ─────────────────────────────────────────────────────────────────
+
+
+def test_ui_js_update_send_btn_function():
+    """ui.js must define updateSendBtn() function."""
+    js, status = get_text("/static/ui.js")
+    assert status == 200
+    assert 'function updateSendBtn' in js
+
+
+def test_update_send_btn_checks_content():
+    """updateSendBtn must check textarea value length."""
+    js, _ = get_text("/static/ui.js")
+    fn_idx = js.find('function updateSendBtn')
+    fn_end = js.find('\n}', fn_idx) + 2
+    fn_body = js[fn_idx:fn_end]
+    assert 'msg' in fn_body
+    assert '.value' in fn_body
+    assert '.length' in fn_body or '.trim()' in fn_body
+
+
+def test_update_send_btn_checks_pending_files():
+    """updateSendBtn must also show send button when files are attached."""
+    js, _ = get_text("/static/ui.js")
+    fn_idx = js.find('function updateSendBtn')
+    fn_end = js.find('\n}', fn_idx) + 2
+    fn_body = js[fn_idx:fn_end]
+    assert 'pendingFiles' in fn_body
+
+
+def test_update_send_btn_uses_visible_class():
+    """updateSendBtn must add .visible class to trigger the pop-in animation."""
+    js, _ = get_text("/static/ui.js")
+    fn_idx = js.find('function updateSendBtn')
+    fn_end = js.find('\n}', fn_idx) + 2
+    fn_body = js[fn_idx:fn_end]
+    assert 'visible' in fn_body
+
+
+def test_update_send_btn_uses_display_none():
+    """updateSendBtn must hide the button with display:none when no content."""
+    js, _ = get_text("/static/ui.js")
+    fn_idx = js.find('function updateSendBtn')
+    fn_end = js.find('\n}', fn_idx) + 2
+    fn_body = js[fn_idx:fn_end]
+    assert 'display' in fn_body
+    assert 'none' in fn_body
+
+
+def test_set_busy_calls_update_send_btn():
+    """setBusy must call updateSendBtn() so button hides while agent is responding."""
+    js, _ = get_text("/static/ui.js")
+    busy_idx = js.find('function setBusy')
+    busy_end = js.find('\n}', busy_idx) + 2
+    busy_body = js[busy_idx:busy_end]
+    assert 'updateSendBtn' in busy_body
+
+
+def test_render_tray_calls_update_send_btn():
+    """renderTray must call updateSendBtn() so button appears when files are attached."""
+    js, _ = get_text("/static/ui.js")
+    tray_idx = js.find('function renderTray')
+    tray_end = js.find('\n}', tray_idx) + 2
+    tray_body = js[tray_idx:tray_end]
+    assert 'updateSendBtn' in tray_body
+
+
+# ── boot.js ──────────────────────────────────────────────────────────────
+
+
+def test_boot_js_input_calls_update_send_btn():
+    """boot.js input event listener must call updateSendBtn()."""
+    js, status = get_text("/static/boot.js")
+    assert status == 200
+    assert 'updateSendBtn' in js
+
+
+# ── messages.js ───────────────────────────────────────────────────────────
+
+
+def test_auto_resize_calls_update_send_btn():
+    """autoResize() must call updateSendBtn() so button hides after send clears textarea."""
+    js, status = get_text("/static/messages.js")
+    assert status == 200
+    assert 'updateSendBtn' in js
+
+
+# ── Regression: existing behaviour unchanged ──────────────────────────────
+
+
+def test_send_button_still_has_send_btn_class():
+    """btnSend must still carry class='send-btn' for CSS targeting."""
+    html, _ = get_text("/")
+    assert 'class="send-btn"' in html
+
+
+def test_ui_js_set_busy_still_disables_btn():
+    """setBusy must still set btnSend.disabled (not just hide it)."""
+    js, _ = get_text("/static/ui.js")
+    busy_idx = js.find('function setBusy')
+    busy_end = js.find('\n}', busy_idx) + 2
+    busy_body = js[busy_idx:busy_end]
+    assert "btnSend" in busy_body
+    assert 'disabled' in busy_body
+
+
+def test_index_html_attach_button_unchanged():
+    """btnAttach must still be present (no regression)."""
+    html, _ = get_text("/")
+    assert 'id="btnAttach"' in html
+
+
+def test_send_function_still_exists():
+    """send() function must still be defined in messages.js."""
+    js, _ = get_text("/static/messages.js")
+    assert 'async function send()' in js

tests/test_sprint23.py

@@ -0,0 +1,196 @@
+"""
+Sprint 23 Tests: agentic transparency — token/cost display, session usage fields,
+subagent card names, skill picker in cron, skill linked files.
+"""
+import json, urllib.error, urllib.request
+
+BASE = "http://127.0.0.1:8788"
+
+
+def get(path):
+    with urllib.request.urlopen(BASE + path, timeout=10) as r:
+        return json.loads(r.read()), r.status
+
+
+def post(path, body=None):
+    data = json.dumps(body or {}).encode()
+    req = urllib.request.Request(BASE + path, data=data,
+                                headers={"Content-Type": "application/json"})
+    try:
+        with urllib.request.urlopen(req, timeout=10) as r:
+            return json.loads(r.read()), r.status
+    except urllib.error.HTTPError as e:
+        return json.loads(e.read()), e.code
+
+
+def make_session(created_list):
+    d, _ = post("/api/session/new", {})
+    sid = d["session"]["session_id"]
+    created_list.append(sid)
+    return sid, d["session"]
+
+
+# ── Session usage fields ─────────────────────────────────────────────────
+
+def test_new_session_has_usage_fields():
+    """New session should include input_tokens, output_tokens, estimated_cost."""
+    created = []
+    try:
+        sid, sess = make_session(created)
+        post("/api/session/rename", {"session_id": sid, "title": "Usage Test"})
+        d, status = get(f"/api/session?session_id={sid}")
+        assert status == 200
+        sess = d["session"]
+        assert "input_tokens" in sess, "input_tokens field missing from session"
+        assert "output_tokens" in sess, "output_tokens field missing from session"
+        assert "estimated_cost" in sess, "estimated_cost field missing from session"
+        assert sess["input_tokens"] == 0
+        assert sess["output_tokens"] == 0
+    finally:
+        for s in created:
+            post("/api/session/delete", {"session_id": s})
+
+
+def test_session_compact_has_usage_fields():
+    """Session list should include usage fields in compact form."""
+    created = []
+    try:
+        sid, _ = make_session(created)
+        post("/api/session/rename", {"session_id": sid, "title": "Compact Usage"})
+        d, status = get("/api/sessions")
+        assert status == 200
+        match = [s for s in d["sessions"] if s["session_id"] == sid]
+        assert len(match) == 1
+        assert "input_tokens" in match[0], "input_tokens missing from session list"
+        assert "output_tokens" in match[0], "output_tokens missing from session list"
+        assert match[0]["input_tokens"] == 0
+        assert match[0]["output_tokens"] == 0
+    finally:
+        for s in created:
+            post("/api/session/delete", {"session_id": s})
+
+
+def test_session_usage_defaults_zero():
+    """New session usage fields should default to 0/None in creation response."""
+    created = []
+    try:
+        sid, sess = make_session(created)
+        assert "input_tokens" in sess, "input_tokens missing from new session response"
+        assert "output_tokens" in sess, "output_tokens missing from new session response"
+        assert sess["input_tokens"] == 0
+        assert sess["output_tokens"] == 0
+    finally:
+        for s in created:
+            post("/api/session/delete", {"session_id": s})
+
+
+# ── Skills content linked_files ──────────────────────────────────────────
+
+def test_skills_content_requires_name():
+    """GET /api/skills/content without name should return 400 (or 500 if skills module unavailable)."""
+    try:
+        d, status = get("/api/skills/content")
+        assert status in (400, 500), f"Expected 400/500 for missing name, got {status}"
+    except urllib.error.HTTPError as e:
+        assert e.code in (400, 500), f"Expected 400/500 for missing name, got {e.code}"
+
+
+def test_skills_content_has_linked_files_key():
+    """GET /api/skills/content should always return a linked_files key."""
+    try:
+        d, status = get("/api/skills")
+        if not d.get("skills"):
+            return  # no skills in test env, skip
+        name = d["skills"][0]["name"]
+        d2, status2 = get(f"/api/skills/content?name={name}")
+        assert status2 == 200
+        assert "linked_files" in d2, "linked_files key missing from skills/content response"
+        # linked_files must be a dict (possibly empty), not None
+        assert isinstance(d2["linked_files"], dict), "linked_files must be a dict"
+    except urllib.error.HTTPError:
+        pass  # skills module unavailable in this env
+
+
+def test_skills_content_file_path_traversal_rejected():
+    """GET /api/skills/content with traversal path should be rejected."""
+    from urllib.parse import quote as _quote
+    try:
+        d, status = get("/api/skills")
+        if not d.get("skills"):
+            return  # no skills in test env, skip
+        name = d["skills"][0]["name"]
+        traversal = _quote("../../etc/passwd", safe="")
+        try:
+            d2, status2 = get(f"/api/skills/content?name={name}&file={traversal}")
+            assert status2 in (400, 404, 500), f"Path traversal should be rejected, got {status2}"
+        except urllib.error.HTTPError as e:
+            assert e.code in (400, 404, 500), f"Path traversal should be rejected, got {e.code}"
+    except urllib.error.HTTPError:
+        pass  # skills module unavailable in test env
+
+
+def test_skills_content_wildcard_name_rejected():
+    """GET /api/skills/content with glob wildcard in name should be rejected when file param present."""
+    try:
+        try:
+            d2, status2 = get("/api/skills/content?name=*&file=SKILL.md")
+            assert status2 == 400, f"Wildcard name should return 400, got {status2}"
+        except urllib.error.HTTPError as e:
+            assert e.code in (400, 404), f"Wildcard name should be rejected, got {e.code}"
+    except Exception:
+        pass
+
+
+# ── Cron create with skills ───────────────────────────────────────────────
+
+def test_cron_create_accepts_skills():
+    """POST /api/crons/create should accept and store a skills array (or 500 if cron module unavailable)."""
+    created_jobs = []
+    try:
+        body = {
+            "name": "test-sprint23-skills",
+            "schedule": "0 9 * * *",
+            "prompt": "test prompt",
+            "deliver": "local",
+            "skills": ["some-skill"]
+        }
+        d, status = post("/api/crons/create", body)
+        if status in (400, 500) and ('module' in str(d.get('error','')) or 'cron' in str(d.get('error',''))):
+            return  # cron module not available in test env
+        assert status == 200, f"Expected 200 from cron create, got {status}: {d}"
+        assert d.get("ok"), f"Cron create did not return ok: {d}"
+        job_id = d.get("job", {}).get("id") or d.get("id")
+        if job_id:
+            created_jobs.append(job_id)
+        # Verify job appears in list
+        jobs_d, _ = get("/api/crons")
+        job = next((j for j in jobs_d.get("jobs", []) if j.get("name") == "test-sprint23-skills"), None)
+        assert job is not None, "Created cron job not found in job list"
+        assert job.get("skills") == ["some-skill"] or job.get("skill") == "some-skill", \
+            f"skills not stored on job: {job}"
+    finally:
+        try:
+            for jid in created_jobs:
+                post("/api/crons/delete", {"id": jid})
+            jobs_d, _ = get("/api/crons")
+            for j in jobs_d.get("jobs", []):
+                if j.get("name") == "test-sprint23-skills":
+                    post("/api/crons/delete", {"id": j["id"]})
+        except Exception:
+            pass  # cron module may not be available
+
+
+# ── Tool call integrity ──────────────────────────────────────────────────
+
+def test_tool_calls_have_real_names():
+    """Tool calls in session JSON should not have unresolved 'tool' name."""
+    created = []
+    try:
+        sid, _ = make_session(created)
+        d, status = get(f"/api/session?session_id={sid}")
+        assert status == 200
+        for tc in d["session"].get("tool_calls", []):
+            assert tc.get("name") not in ("tool", "", None), f"Unresolved tool name: {tc}"
+    finally:
+        for s in created:
+            post("/api/session/delete", {"session_id": s})

tests/test_sprint26.py

@@ -0,0 +1,119 @@
+"""
+Sprint 26 Tests: pluggable UI themes — settings persistence, theme default,
+custom theme names accepted.
+"""
+import json, urllib.error, urllib.request
+
+BASE = "http://127.0.0.1:8788"
+
+
+def get(path):
+    with urllib.request.urlopen(BASE + path, timeout=10) as r:
+        return json.loads(r.read()), r.status
+
+
+def post(path, body=None):
+    data = json.dumps(body or {}).encode()
+    req = urllib.request.Request(BASE + path, data=data,
+                                headers={"Content-Type": "application/json"})
+    try:
+        with urllib.request.urlopen(req, timeout=10) as r:
+            return json.loads(r.read()), r.status
+    except urllib.error.HTTPError as e:
+        return json.loads(e.read()), e.code
+
+
+# ── Theme settings ───────────────────────────────────────────────────────
+
+def test_settings_default_theme():
+    """Default theme should be 'dark'."""
+    d, status = get("/api/settings")
+    assert status == 200
+    assert d.get("theme") == "dark"
+
+
+def test_settings_set_theme_light():
+    """Setting theme to 'light' should persist and round-trip."""
+    try:
+        d, status = post("/api/settings", {"theme": "light"})
+        assert status == 200
+        d2, _ = get("/api/settings")
+        assert d2.get("theme") == "light"
+    finally:
+        # Reset to dark
+        post("/api/settings", {"theme": "dark"})
+
+
+def test_settings_set_theme_solarized():
+    """Setting theme to 'solarized' should persist."""
+    try:
+        post("/api/settings", {"theme": "solarized"})
+        d, _ = get("/api/settings")
+        assert d.get("theme") == "solarized"
+    finally:
+        post("/api/settings", {"theme": "dark"})
+
+
+def test_settings_set_theme_monokai():
+    """Setting theme to 'monokai' should persist."""
+    try:
+        post("/api/settings", {"theme": "monokai"})
+        d, _ = get("/api/settings")
+        assert d.get("theme") == "monokai"
+    finally:
+        post("/api/settings", {"theme": "dark"})
+
+
+def test_settings_set_theme_nord():
+    """Setting theme to 'nord' should persist."""
+    try:
+        post("/api/settings", {"theme": "nord"})
+        d, _ = get("/api/settings")
+        assert d.get("theme") == "nord"
+    finally:
+        post("/api/settings", {"theme": "dark"})
+
+
+def test_settings_set_theme_slate():
+    """Setting theme to 'slate' should persist."""
+    try:
+        post("/api/settings", {"theme": "slate"})
+        d, _ = get("/api/settings")
+        assert d.get("theme") == "slate"
+    finally:
+        post("/api/settings", {"theme": "dark"})
+
+
+def test_settings_custom_theme_accepted():
+    """Custom theme names should be accepted (no enum gate)."""
+    try:
+        d, status = post("/api/settings", {"theme": "my-custom-theme"})
+        assert status == 200
+        d2, _ = get("/api/settings")
+        assert d2.get("theme") == "my-custom-theme"
+    finally:
+        post("/api/settings", {"theme": "dark"})
+
+
+def test_theme_does_not_break_other_settings():
+    """Setting theme should not disturb other settings."""
+    d_before, _ = get("/api/settings")
+    send_key_before = d_before.get("send_key")
+    try:
+        post("/api/settings", {"theme": "nord"})
+        d_after, _ = get("/api/settings")
+        assert d_after.get("send_key") == send_key_before
+        assert d_after.get("theme") == "nord"
+    finally:
+        post("/api/settings", {"theme": "dark"})
+
+
+def test_theme_survives_round_trip():
+    """Theme set via POST should appear in subsequent GET."""
+    try:
+        post("/api/settings", {"theme": "monokai"})
+        d, status = get("/api/settings")
+        assert status == 200
+        assert d["theme"] == "monokai"
+    finally:
+        post("/api/settings", {"theme": "dark"})

tests/test_sprint27.py

@@ -0,0 +1,136 @@
+"""
+Sprint 27 Tests: configurable assistant display name (bot_name).
+Tests cover settings API round-trip, empty/missing input defaults,
+login page rendering, and server-side sanitization.
+"""
+import json
+import urllib.error
+import urllib.request
+
+BASE = "http://127.0.0.1:8788"
+
+
+def get(path):
+    with urllib.request.urlopen(BASE + path, timeout=10) as r:
+        return json.loads(r.read()), r.status
+
+
+def get_raw(path):
+    with urllib.request.urlopen(BASE + path, timeout=10) as r:
+        return r.read().decode(), r.status
+
+
+def post(path, body=None):
+    data = json.dumps(body or {}).encode()
+    req = urllib.request.Request(BASE + path, data=data,
+                                 headers={"Content-Type": "application/json"})
+    try:
+        with urllib.request.urlopen(req, timeout=10) as r:
+            return json.loads(r.read()), r.status
+    except urllib.error.HTTPError as e:
+        return json.loads(e.read()), e.code
+
+
+# ── Default value ─────────────────────────────────────────────────────────
+
+def test_settings_default_bot_name():
+    """GET /api/settings should return bot_name defaulting to 'Hermes'."""
+    d, status = get("/api/settings")
+    assert status == 200
+    assert "bot_name" in d
+    assert d["bot_name"] == "Hermes"
+
+
+# ── Round-trip ────────────────────────────────────────────────────────────
+
+def test_settings_set_bot_name():
+    """POST /api/settings with bot_name should persist and round-trip."""
+    try:
+        d, status = post("/api/settings", {"bot_name": "TestBot"})
+        assert status == 200
+        assert d.get("bot_name") == "TestBot"
+        d2, _ = get("/api/settings")
+        assert d2.get("bot_name") == "TestBot"
+    finally:
+        post("/api/settings", {"bot_name": "Hermes"})
+
+
+def test_settings_bot_name_special_chars():
+    """bot_name with safe special characters should persist correctly."""
+    try:
+        d, status = post("/api/settings", {"bot_name": "My Assistant 2.0"})
+        assert status == 200
+        d2, _ = get("/api/settings")
+        assert d2.get("bot_name") == "My Assistant 2.0"
+    finally:
+        post("/api/settings", {"bot_name": "Hermes"})
+
+
+# ── Server-side sanitization ──────────────────────────────────────────────
+
+def test_settings_empty_bot_name_defaults_to_hermes():
+    """Posting an empty bot_name should default to 'Hermes' server-side."""
+    try:
+        d, status = post("/api/settings", {"bot_name": ""})
+        assert status == 200
+        assert d.get("bot_name") == "Hermes"
+        d2, _ = get("/api/settings")
+        assert d2.get("bot_name") == "Hermes"
+    finally:
+        post("/api/settings", {"bot_name": "Hermes"})
+
+
+def test_settings_whitespace_bot_name_defaults_to_hermes():
+    """Posting a whitespace-only bot_name should default to 'Hermes'."""
+    try:
+        d, status = post("/api/settings", {"bot_name": "   "})
+        assert status == 200
+        assert d.get("bot_name") == "Hermes"
+    finally:
+        post("/api/settings", {"bot_name": "Hermes"})
+
+
+# ── Login page rendering ──────────────────────────────────────────────────
+
+def test_login_page_shows_default_bot_name():
+    """GET /login should contain 'Hermes' in title and h1 when default."""
+    html, status = get_raw("/login")
+    assert status == 200
+    assert "<title>Hermes" in html
+    assert "<h1>Hermes</h1>" in html
+
+
+def test_login_page_shows_custom_bot_name():
+    """GET /login should reflect the configured bot_name."""
+    try:
+        post("/api/settings", {"bot_name": "Aria"})
+        html, status = get_raw("/login")
+        assert status == 200
+        assert "<title>Aria" in html
+        assert "<h1>Aria</h1>" in html
+    finally:
+        post("/api/settings", {"bot_name": "Hermes"})
+
+
+def test_login_page_empty_name_does_not_crash():
+    """Login page must not 500 even if somehow bot_name is empty in settings."""
+    # Force an empty value by patching settings file directly — skipped here
+    # because the server-side guard in POST /api/settings prevents storing empty.
+    # Instead, verify that /login returns 200 reliably.
+    html, status = get_raw("/login")
+    assert status == 200
+    assert "Sign in" in html
+
+
+def test_login_page_xss_escaped():
+    """bot_name with HTML special chars should be escaped in the login page."""
+    try:
+        post("/api/settings", {"bot_name": "<script>alert(1)</script>"})
+        html, status = get_raw("/login")
+        assert status == 200
+        # Raw tag must not appear unescaped
+        assert "<script>alert(1)</script>" not in html
+        # Escaped form should appear
+        assert "&lt;script&gt;" in html
+    finally:
+        post("/api/settings", {"bot_name": "Hermes"})

tests/test_sprint28.py

@@ -0,0 +1,224 @@
+"""
+Sprint 28 Tests: /personality slash command — backend API coverage.
+Tests: GET /api/personalities, POST /api/personality/set, Session.compact(),
+path traversal defence, size cap, clear personality.
+"""
+import json
+import pathlib
+import shutil
+import sys
+import urllib.error
+import urllib.request
+
+# Import test constants from conftest (same process — these are module-level values)
+sys.path.insert(0, str(pathlib.Path(__file__).parent))
+from conftest import TEST_STATE_DIR
+
+BASE = "http://127.0.0.1:8788"
+
+
+def get(path):
+    with urllib.request.urlopen(BASE + path, timeout=10) as r:
+        return json.loads(r.read()), r.status
+
+
+def post(path, body=None):
+    data = json.dumps(body or {}).encode()
+    req = urllib.request.Request(BASE + path, data=data,
+                                 headers={"Content-Type": "application/json"})
+    try:
+        with urllib.request.urlopen(req, timeout=10) as r:
+            return json.loads(r.read()), r.status
+    except urllib.error.HTTPError as e:
+        return json.loads(e.read()), e.code
+
+
+def _personalities_dir():
+    """Return the personalities directory the test server will look in.
+
+    conftest sets HERMES_HOME=TEST_STATE_DIR in the server's environment.
+    The server's api/profiles._DEFAULT_HERMES_HOME resolves to TEST_STATE_DIR,
+    so get_active_hermes_home() returns TEST_STATE_DIR, and personalities
+    live at TEST_STATE_DIR/personalities.
+    """
+    p = TEST_STATE_DIR / 'personalities'
+    p.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+def _make_personality(name, content="# Test Bot\nA test personality."):
+    """Create a personality directory with a SOUL.md."""
+    d = _personalities_dir() / name
+    d.mkdir(parents=True, exist_ok=True)
+    (d / "SOUL.md").write_text(content)
+    return d
+
+
+def _make_session():
+    """Create a new session and return its session_id."""
+    d, status = post("/api/session/new", {})
+    assert status == 200, f"Failed to create session: {d}"
+    return d["session"]["session_id"]
+
+
+def _cleanup_session(sid):
+    try:
+        post("/api/session/delete", {"session_id": sid})
+    except Exception:
+        pass
+
+
+# ── GET /api/personalities ────────────────────────────────────────────────────
+
+def test_personalities_empty_when_none_exist():
+    """GET /api/personalities returns empty list when no personalities exist."""
+    p_dir = _personalities_dir()
+    for child in list(p_dir.iterdir()):
+        if child.is_dir() and not child.is_symlink():
+            shutil.rmtree(child)
+    d, status = get("/api/personalities")
+    assert status == 200
+    assert d.get("personalities") == []
+
+
+def test_personalities_lists_from_config():
+    """GET /api/personalities returns personalities from config.yaml agent.personalities.
+    Skipped if no personalities configured in test environment.
+    """
+    d, status = get("/api/personalities")
+    assert status == 200
+    assert isinstance(d.get("personalities"), list)
+    # If personalities are configured, verify structure
+    for p in d.get("personalities", []):
+        assert "name" in p
+        assert "description" in p
+
+
+def test_personalities_returns_empty_when_none_configured():
+    """GET /api/personalities returns empty list when no personalities in config."""
+    # The test server starts with a clean state dir (no config.yaml),
+    # so agent.personalities is empty by default
+    d, status = get("/api/personalities")
+    assert status == 200
+    # May or may not have personalities depending on the real ~/.hermes/config.yaml
+    # being loaded. Just verify the structure is correct.
+    assert isinstance(d.get("personalities"), list)
+
+
+def test_personalities_skips_non_dict_config():
+    """GET /api/personalities handles non-dict agent config gracefully."""
+    d, status = get("/api/personalities")
+    assert status == 200
+    assert isinstance(d.get("personalities"), list)
+
+
+# ── POST /api/personality/set ─────────────────────────────────────────────────
+
+_test_personalities = {}
+
+def _inject_personality(name, value):
+    """Write a personality into the test config.yaml so the server picks it up."""
+    _test_personalities[name] = value
+    _write_test_config()
+
+def _remove_personality(name):
+    """Remove a personality from the test config.yaml."""
+    _test_personalities.pop(name, None)
+    _write_test_config()
+
+def _write_test_config():
+    """Write config.yaml with test personalities using simple YAML format."""
+    TEST_STATE_DIR.mkdir(parents=True, exist_ok=True)
+    config_path = TEST_STATE_DIR / 'config.yaml'
+    lines = ['agent:', '  personalities:']
+    for pname, pval in _test_personalities.items():
+        if isinstance(pval, dict):
+            lines.append(f'    {pname}:')
+            for k, v in pval.items():
+                lines.append(f'      {k}: "{v}"')
+        else:
+            lines.append(f'    {pname}: "{pval}"')
+    config_path.write_text('\n'.join(lines) + '\n')
+
+
+def test_set_personality_valid():
+    """Setting a personality that exists in config stores name and returns prompt.
+    Skipped if config.yaml has no personalities (common in test environments).
+    """
+    # First check if any personalities are configured
+    d, status = get("/api/personalities")
+    if not d.get("personalities"):
+        return  # skip — no personalities in test server config
+    name = d["personalities"][0]["name"]
+    sid = _make_session()
+    try:
+        d2, status2 = post("/api/personality/set", {"session_id": sid, "name": name})
+        assert status2 == 200
+        assert d2.get("ok") is True
+        assert d2.get("personality") == name
+    finally:
+        _cleanup_session(sid)
+
+
+def test_set_personality_persists_in_compact():
+    """After setting personality, GET /api/session returns personality in compact.
+    Skipped if config.yaml has no personalities.
+    """
+    d, status = get("/api/personalities")
+    if not d.get("personalities"):
+        return  # skip
+    name = d["personalities"][0]["name"]
+    sid = _make_session()
+    try:
+        post("/api/personality/set", {"session_id": sid, "name": name})
+        d2, status2 = get(f"/api/session?session_id={sid}")
+        assert status2 == 200
+        session = d2.get("session", {})
+        assert session.get("personality") == name
+    finally:
+        _cleanup_session(sid)
+
+
+def test_clear_personality_sets_null():
+    """Clearing personality with name='' sets it to None (null in JSON)."""
+    sid = _make_session()
+    try:
+        # Set a personality name directly on the session (no config validation needed for clear)
+        d, status = post("/api/personality/set", {"session_id": sid, "name": ""})
+        assert status == 200
+        assert d.get("personality") is None
+        # Verify persisted
+        d2, s2 = get(f"/api/session?session_id={sid}")
+        assert s2 == 200
+        assert d2.get("session", {}).get("personality") is None
+    finally:
+        _cleanup_session(sid)
+
+
+def test_set_personality_not_found_returns_404():
+    """Setting a non-existent personality returns 404."""
+    sid = _make_session()
+    try:
+        d, status = post("/api/personality/set",
+                         {"session_id": sid, "name": "doesnotexist"})
+        assert status == 404
+    finally:
+        _cleanup_session(sid)
+
+
+def test_set_personality_nonexistent_returns_404():
+    """Names not in config.yaml agent.personalities return 404."""
+    sid = _make_session()
+    try:
+        d, status = post("/api/personality/set",
+                         {"session_id": sid, "name": "doesnotexist"})
+        assert status == 404, f"Expected 404, got {status}: {d}"
+    finally:
+        _cleanup_session(sid)
+
+
+def test_set_personality_missing_session_returns_404():
+    """Setting personality on non-existent session returns 404."""
+    d, status = post("/api/personality/set",
+                     {"session_id": "nonexistent000", "name": "x"})
+    assert status == 404