From 3953dcf3648225056baba9347b7c436edbb51933 Mon Sep 17 00:00:00 2001
From: xcaliber <jasafpro@gmail.com>
Date: Mon, 2 Mar 2026 22:16:08 +0000
Subject: [PATCH] Changeset 0.22.4 (#146)

---
 CHANGELOG.md                                  |   34 +
 VERSION                                       |    2 +-
 docs/ARCHITECTURE.md                          |    5 +-
 docs/ROADMAP.md                               | 1290 +++++++++++++++--
 server/config/config.go                       |    7 +
 .../migrations/015_v0224_health_enhance.sql   |   33 +
 .../sqlite/014_v0224_health_enhance.sql       |   22 +
 server/handlers/attachments.go                |  115 ++
 server/handlers/completion.go                 |    5 +
 server/handlers/export.go                     |  110 ++
 server/handlers/health_admin.go               |    3 +
 server/handlers/stream_loop.go                |   27 +-
 server/health/accumulator.go                  |  220 ++-
 server/health/accumulator_test.go             |    8 +
 server/main.go                                |   36 +-
 server/models/models.go                       |   28 +
 server/store/interfaces.go                    |    1 +
 server/store/postgres/attachment.go           |   31 +-
 server/store/postgres/health.go               |   94 +-
 server/store/sqlite/attachment.go             |   31 +-
 server/store/sqlite/health.go                 |   94 +-
 src/js/api.js                                 |   29 +
 src/js/editor-mode.js                         |   33 +
 src/js/projects-ui.js                         |  137 ++
 src/js/ui-admin.js                            |    4 +
 25 files changed, 2254 insertions(+), 145 deletions(-)
 create mode 100644 server/database/migrations/015_v0224_health_enhance.sql
 create mode 100644 server/database/migrations/sqlite/014_v0224_health_enhance.sql
 create mode 100644 server/handlers/export.go

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 446789e..df3a87a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,40 @@
 
 All notable changes to Chat Switchboard.
 
+## [0.22.4] — 2026-03-02
+
+### Added
+- **Rate limit tracking.** Provider health windows now track HTTP 429 / rate limit events separately from general errors. New `rate_limit_count` column on `provider_health` table. `RecordRateLimit()` method on health accumulator. Completion handler and stream loop classify `HTTP 429` / `rate limit` / `Too Many Requests` errors automatically.
+- **Auto-disable policy.** Providers that report "down" status for N consecutive hourly windows are automatically deactivated. Configurable via `PROVIDER_AUTO_DISABLE_THRESHOLD` env var (default: 3, set to 0 to disable). `AutoDisabler` interface on health store, `checkAutoDisable()` runs on each flush cycle.
+- **Tool health tracking.** Built-in tools (web_search, url_fetch, etc.) now record success/error/latency to `tool_health` table via the health accumulator. `RecordToolSuccess()` / `RecordToolError()` methods. Both tool execution sites in stream loop instrumented. `ToolHealthWindow` and `ToolHealthSummary` models.
+- **Search provider health tracking.** web_search and url_fetch tool calls are now included in the tool health pipeline with per-invocation latency and error recording.
+- **Project-specific file uploads.** `POST /api/v1/projects/:id/files` (multipart upload) and `GET /api/v1/projects/:id/files` (list). `project_id` column on `attachments` table. Files are stored under `projects/{id}/` prefix. Project access verified via ownership or team membership. Files queued for text extraction if enabled.
+- **Workspace settings UI.** Git configuration section in project settings panel: remote URL, branch, credential selector. Appears when a workspace is bound. Saves via `PATCH /api/v1/workspaces/:id`. `updateWorkspace()` and `listGitCredentials()` API client methods.
+- **PDF/DOCX export via pandoc.** New `POST /api/v1/export` endpoint converts markdown content to PDF or DOCX using pandoc. Editor export dropdown now includes "Export as PDF" and "Export as DOCX" options. Graceful error handling when pandoc is unavailable.
+- **Project files UI.** File list and upload button in project settings panel. Shows file names and sizes. Multi-file upload support.
+- **API client methods.** `projectUploadFile`, `projectListFiles`, `exportDocument`, `updateWorkspace`, `listGitCredentials`.
+
+### Changed
+- `health/accumulator.go`: Added `rateLimitCount` to bucket, `RecordRateLimit()`, `RecordToolSuccess()`, `RecordToolError()`, `flushTools()`, `checkAutoDisable()`, `SetAutoDisable()`, `AutoDisabler` interface, `toolBucket` struct. `Store` interface extended with `UpsertToolWindow()`, `ListAllToolCurrent()`.
+- `handlers/completion.go`: `HealthRecorder` interface extended with `RecordRateLimit()`, `RecordToolSuccess()`, `RecordToolError()`. `recordHealth()` classifies HTTP 429 errors.
+- `handlers/stream_loop.go`: Both tool execution sites now record tool health. `recordHealthFn()` classifies rate limit errors.
+- `models/models.go`: `RateLimitCount` field on `ProviderHealthWindow`. `ToolHealthWindow`, `ToolHealthSummary` types. `ErrorCount`, `RateLimitCount`, `TimeoutCount` fields on `ProviderHealthSummary`. `ProjectID` field on `Attachment`.
+- `store/postgres/health.go`: All queries updated for `rate_limit_count`. `UpsertToolWindow()`, `ListAllToolCurrent()`, `DeactivateProvider()` methods.
+- `store/sqlite/health.go`: Full rewrite with rate_limit_count, tool health, and auto-disable support.
+- `store/postgres/attachment.go`: `project_id` in cols, scan, create, and new `GetByProject()`.
+- `store/sqlite/attachment.go`: Same project_id additions.
+- `store/interfaces.go`: `GetByProject()` on `AttachmentStore`.
+- `config/config.go`: `ProviderAutoDisableThreshold` field + env var loading.
+- `main.go`: SQLite health store branching, auto-disable wiring, export handler route, project file routes.
+- `handlers/health_admin.go`: Health summary includes error_count, rate_limit_count, timeout_count.
+- `src/js/ui-admin.js`: Health dashboard cards show "Rate Limits" count with warning color.
+- `src/js/projects-ui.js`: Git settings section, project files section, file upload handler.
+- `src/js/editor-mode.js`: PDF and DOCX export menu items and handler.
+- `src/js/api.js`: 5 new API client methods.
+
+### Database
+- Migration 015 (Postgres) / 014 (SQLite): `rate_limit_count` column on `provider_health`, `tool_health` table, `project_id` column on `attachments`.
+
 ## [0.22.3] — 2026-03-02
 
 ### Added
diff --git a/VERSION b/VERSION
index fabc491..4240544 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.22.3
\ No newline at end of file
+0.22.4
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index c30e553..2871313 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -151,14 +151,14 @@ server/
 ├── crypto/                    # AES-256-GCM API key encryption
 ├── events/                    # EventBus + WebSocket hub
 ├── extraction/                # Document text extraction pipeline
-├── health/                    # Provider health tracking (v0.22.0)
+├── health/                    # Provider health tracking (v0.22.0), tool health + auto-disable (v0.22.4)
 ├── routing/                   # Policy-based request routing (v0.22.2)
 │   ├── types.go               # Policy, Candidate, Context, Decision types
 │   ├── evaluator.go           # Policy evaluation engine (4 policy types)
 │   ├── evaluator_test.go      # 12 tests
 │   ├── fallback.go            # RunWithFallback candidate dispatcher
 │   └── convert.go             # DB model → routing type conversion
-│   ├── accumulator.go         # In-memory counters, 60s flush to DB, status derivation
+│   ├── accumulator.go         # In-memory counters, 60s flush, rate limits, tool health, auto-disable
 │   └── accumulator_test.go    # Concurrent recording, flush isolation, threshold tests
 ├── memory/                    # Long-term memory extraction + scanning
 │   ├── extractor.go           # Conversation analysis → fact extraction
@@ -178,6 +178,7 @@ server/
 │   ├── stream_loop.go         # Shared streaming + tool execution loop
 │   ├── capabilities.go        # ModelHandler: model list + health enrichment + ResolveModelCaps (v0.22.3)
 │   ├── health_admin.go        # Provider health + capability override admin endpoints
+│   ├── export.go              # Markdown → PDF/DOCX conversion via pandoc (v0.22.4)
 │   ├── routing_admin.go       # Routing policy CRUD + dry-run test (v0.22.2)
 │   ├── presets.go             # Persona CRUD (all scopes)
 │   ├── apiconfigs.go          # User provider config CRUD (BYOK)
diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md
index 3d5b602..8416fd6 100644
--- a/docs/ROADMAP.md
+++ b/docs/ROADMAP.md
@@ -17,129 +17,1220 @@ Features have real dependencies. This ordering respects them.
 
 ```
 v0.9.x  Stability + Quick UX Wins              ✅
-        │
-v0.10.x Providers + Models + Roles             ✅
-        │
-v0.11.x Tool Framework + Extension Base        ✅
-        │
-v0.12.x File Storage + Vision                  ✅
-        │
-v0.13.x Web Tools + Toggle                     ✅
-        │
-v0.14.x Knowledge Bases (RAG)                  ✅
-        │
-v0.15.x Auto-Compaction                        ✅
-        │
-v0.16.x Groups + Resource Grants               ✅
-        │
-v0.17.x Personas + Notes/CM6 + SQLite          ✅
-        │
-v0.18.x Memory System                          ✅
-        │
-v0.19.x Projects/Workspaces                    ✅
-        │
-v0.20.x Surface System                         ✅
-        │
-v0.21.x Admin UX + Routing                     ✅
-        │
-v0.22.x Routing Policies + Provider Chains     ✅
-        │
-v1.0    Stability + Multi-Tenant               ⏳
+          │
+v0.9.3  Content Visibility & Block Controls     ✅
+          │
+v0.9.4  API Key Encryption + Vault              ✅
+          │
+v0.10.0 Model Roles (utility + embedding)       ✅
+        + Usage Tracking
+          │
+v0.10.2 Summarize & Continue                    ✅
+          │
+v0.10.3 Frontend Refactor                       ✅
+          │
+v0.10.4 Model Type Pipeline + Role Fixes        ✅
+          │
+v0.10.5 UI Primitives + Extension Surfaces      ✅
+          │
+v0.11.0 Extension Foundation (browser tier)     ✅
+          │
+  ┌───────┴──────────────┐
+  │                      │
+v0.12.0 File Handling  v0.13.0 Admin Panel
+  + Vision ✅            Refactor (fullscreen) ✅
+  │                      │
+  │                    v0.13.1 Web Search
+  │                      + url_fetch ✅
+  │                      │
+  └───────┬──────────────┘
+          │
+v0.14.0 Knowledge Bases ✅ (embedding role + file storage + pgvector)
+          │
+v0.15.0 Compaction ✅ (utility role + background job)
+          │
+v0.15.1 Context Recall Tools ✅ (attachment_recall, conversation_search)
+          │
+  ┌───────┴──────────────┐
+  │                      │
+v0.16.0 User Groups    v0.17.0 Persona-KB Binding
+  + Resource Grants ✅   + Enterprise KB Mode
+  │                      + QOL / UX Wins
+  └───────┬──────────────┘
+          │
+  ┌───────┴──────────────┐
+  │                      │
+v0.17.1 SQLite Backend ✅ v0.17.2 CodeMirror 6 ✅
+v0.17.3 Notes Graph + Wikilinks ✅
+  (dual DB)              (editor bundle, chat
+  │                       input, ext editor)
+  └───────┬──────────────┘
+          │
+v0.18.0 Memory ✅ (user + persona scopes, review pipeline)
+          │
+v0.18.1 Side Panel Architecture ✅ (single-slot, ctx.ui primitives, mermaid refactor)
+          │
+v0.19.0 Projects / Workspaces ✅ (project groups, KB resolution, drag-drop sidebar)
+          │
+v0.19.1 Active Project + System Prompt + Detail Panel ✅
+          │
+v0.19.2 Project Persona Default + Archive + Reorder ✅
+          │
+v0.20.0 Notifications + @mention Routing + Multi-model   ✅
+          │
+v0.21.0 Workspace Storage Primitive                      ✅
+          │
+  ┌───────┴──────────────┐
+  │                      │
+v0.21.1 Workspace ✅   v0.21.3 Surface Infra ✅
+  Tools + Bindings       + REPL (parallel)
+  │                      │
+v0.21.2 Workspace ✅   v0.21.5 Editor Surface ✅
+  Indexing + Search      (Development Mode)
+  │                      │
+v0.21.4 Git ✅         v0.21.6 Editor Surface ✅
+  Integration            + Document Output
+  └───────┬──────────────┘
+          │
+v0.21.7 Bugfix: scanJSON driver buffer aliasing   ✅
+          │
+v0.22.0 Provider Health + Capability Overrides     ✅
+  + Workspace Pane Refactor (FE)
+          │
+v0.22.1 Provider Extensions (declarative config)   ✅
+          │
+v0.22.2 Routing Policies + Fallback Chains          ✅
+          │
+v0.22.3 Provider Admin UI + Deferred Polish          ✅
+          │
+v0.22.4 Provider Health UX + Project Files + Export   ✅
+          │
+v0.23.0 Multi-Participant Channels + Presence
+          │
+v0.24.0 Auth Strategy (mTLS/OIDC) + Full RBAC + Group permissions
+          │
+  ┌───────┴──────────────┐
+  │                      │
+v0.25.0 Workflow       v0.26.0 Tasks /
+  Engine                 Autonomous Agents
+  (team-owned,           (service channels,
+   staged processes,      scheduler, unattended
+   human + AI collab)     execution)
 ```
 
+---
+
 ## Completed Releases
 
-### ✅ v0.22.3 — Provider Admin UI + Deferred Polish
+> Full details for all completed versions are in [CHANGELOG.md](../CHANGELOG.md).
+
+### ✅ v0.9.0 — Schema Consolidation + BYOK
+21 migrations → single schema, store layer abstraction, persona-as-trust-boundary,
+BYOK with auto-fetch, composite model IDs, journey integration tests.
+
+### ✅ v0.9.1 — Capability Architecture + Docs
+Removed static known model table. Resolution chain: catalog → heuristic only.
+Frontend relies solely on backend for capabilities. Docs rewrite.
+
+### ✅ v0.9.2 — Quick UX Wins + Hardening
+Collapsible code blocks, HTML preview, token counter, context warning, proxy
+interception detection, environment injection, team admin audit scoping.
+
+### ✅ v0.9.3 — Content Visibility & Block Controls
+Button-driven code collapse, always-rendered thinking blocks, tool call
+persistence in history, Notes panel → unified side panel, streaming refactor
+(`streamWithToolLoop`), regenerate fix.
+
+### ✅ v0.9.4 — API Key Encryption + Vault
+Two-tier AES-256-GCM: env-var key for global/team, per-user UEK (Argon2id)
+for personal BYOK. `server/crypto/` package. Migration 003. Startup backfill.
+DOMPurify strict allowlist (XSS fix).
+
+### ✅ v0.10.0 — Model Roles + Usage Tracking + Vault Debt
+Named role slots (utility, embedding) with fallback. `Provider.Embed()` interface.
+`usage_log` + `model_pricing` tables. Streaming token capture. Vault debt:
+UEK re-wrap on password change, destruction on admin reset.
+
+### ✅ v0.10.1 — Polish + UX
+Admin system prompt injection, Personas tab, Team Management modal extraction,
+preview pane enhancements, code download, personal usage scoped to BYOK.
+
+### ✅ v0.10.2 — Summarize & Continue + Role Cleanup
+User-triggered conversation compaction via utility role. Summary as tree node
+with boundary metadata. BYOK role overrides (personal → team → global).
+Utility rate limiting. Generation role removed.
+
+### ✅ v0.10.3 — Frontend Refactor
+2 monolith files → 13 domain-scoped files (~544 lines avg). Zero features,
+no function renames. Vanilla JS, no build step.
+See [REFACTOR-0.10.3.md](REFACTOR-0.10.3.md).
+
+### ✅ v0.10.4 — Model Type Pipeline + Role Fixes
+`model_type` (chat/embedding/image) captured end-to-end from provider API
+through catalog to frontend. Role dropdowns filter by type.
+
+### ✅ v0.10.5 — UI Primitives + Extension Surfaces
+Shared `Providers`/`Roles` registries, 6 consolidated render primitives,
+`showConfirm()` replacing native dialogs, `.popup-menu` CSS primitive.
+Removed ~400 lines of duplication.
+
+### ✅ v0.11.0 — Extension Foundation (Browser Tier)
+Full extension lifecycle: manifest, loader, scoped `ctx.*` API, browser tool
+bridge via WebSocket. Custom renderer pipeline. 2 server tools (calculator,
+datetime), 6 built-in browser extensions (Mermaid, KaTeX, CSV, Diff, JS
+Sandbox, Regex). See [EXTENSIONS.md](EXTENSIONS.md).
+
+### ✅ v0.12.0 — File Handling + Vision
+S3/PVC storage backend, image/file upload (📎, drag-drop, paste), multimodal
+message assembly, text extraction pipeline (PDF/DOCX/XLSX/PPTX/ODT/RTF),
+vault CLI (`rekey`/`status`), per-chat model persistence.
+
+### ✅ v0.13.0 — Admin Panel Refactor
+12-tab modal → fullscreen admin panel. 4 categories (People, AI, System,
+Monitoring) × section sidebar. URL-based routing, responsive, banner-aware.
+CSS design token cleanup.
+
+### ✅ v0.13.1 — Web Search + URL Fetch
+`web_search` + `url_fetch` tools. Search provider abstraction (DuckDuckGo,
+SearXNG). Tool categories with per-tool toggle UI in chat bar.
+
+### ✅ v0.14.0 — Knowledge Bases
+RAG: upload → chunk → embed (pgvector) → `kb_search` tool. Channel KB toggle.
+Team/personal KB scopes. Notes semantic search. Admin panel KB management.
+See [DESIGN-0.14.0.md](DESIGN-0.14.0.md).
+
+### ✅ v0.15.0 — Compaction
+Background scanner with configurable thresholds. Automatic summarization via
+utility role. Per-channel opt-in/out. Context budget guard rail (80% ceiling).
+
+### ✅ v0.15.1 — Context Recall Tools
+`attachment_recall` (list + read, channel-scoped), `conversation_search`
+(full-text via `plainto_tsquery`). Token estimator attachment awareness.
+
+### ✅ v0.16.0 — User Groups + Resource Grants
+Groups (global/team-scoped ACLs) decoupled from team membership. Three-way
+resource grants (team_only/global/groups) for Personas and KBs. Grant picker
+UI. Schema consolidation: 9 migrations → single `001_v016_schema.sql`.
+
+---
+
+## v0.17.0 — Persona-KB Binding + Enterprise KB Mode + QOL ✅
+
+Personas become **gateways** to knowledge. In enterprise deployments,
+users don't interact with KBs directly — they talk to Personas that
+have KBs attached. Plus quality-of-life improvements: chat rename,
+token display, state persistence, utility model auto-naming.
+
+Depends on: knowledge bases (v0.14.0), user groups (v0.16.0).
+
+**Persona-KB Binding**
+- [x] `persona_knowledge_bases` table: `persona_id`, `kb_id`, `auto_search` (bool — always search vs tool-only)
+- [x] When a channel uses a Persona with bound KBs, `kb_search` is auto-scoped to those KBs
+- [x] No user toggle needed — Persona carries its own KB context
+- [x] Channel KB toggle becomes "additional KBs" on top of Persona-provided ones
+- [x] Persona system prompt auto-includes KB listing hint (reuses `BuildKBHint` pattern)
+- [x] Admin/team admin UI: KB picker on Persona create/edit form
+
+**Enterprise KB Mode**
+- [x] `discoverable` flag on knowledge_bases: `true` (default — appears in user's KB popup) or `false` (hidden, only accessible through Persona binding)
+- [x] Hidden KBs don't appear in `GET /api/v1/knowledge-bases-discoverable` for non-admins
+- [x] Hidden KBs still searchable by `kb_search` tool when accessed through a Persona
+- [x] Admin panel: toggle discoverability per KB
+- [x] Platform policy: `kb_direct_access` — when `false`, disables channel KB popup entirely (strict enterprise mode)
+
+**Access Control Integration**
+- [x] Persona grants (v0.16.0 groups) control who can *use* a Persona
+- [x] KB grants control who can *manage* a KB (upload/delete docs)
+- [x] Persona-KB binding grants implicit *search* access through the Persona
+- [x] Users who can use a Persona can search its KBs, even if they can't see those KBs directly
+
+**Team Admin Workflow**
+- [x] Team admin creates KB → uploads documents → marks non-discoverable
+- [x] Team admin creates Persona → binds KBs → sets access to Team Only or specific Groups
+- [x] Team members see the Persona in their preset list, use it, get KB-powered answers
+- [x] Team members never see or manage the underlying KBs
+
+**Technical Debt (carried forward)**
+- [x] **Security**: KB create handler authorization — team/global scope verified
+- [x] **Test hygiene**: stripped DIAG diagnostics from `TestGroupBasedPersonaAccess`
+- [x] **Architecture**: `KnowledgeBaseStore.UpdateDocumentStorageKey()` — moved to store layer
+- [x] **UX**: Embedding dropdown fix — tolerant type filter, manual model ID fallback, auto-switch on empty _(already implemented in `ui-primitives.js`)_
+- [x] **Minor**: Paste-to-file character threshold — synced from backend `PublicSettings` (`storage.paste_to_file_chars`), admin-configurable, default 2000
+
+**Role Fallback Alerts** ([#69](https://git.gobha.me/xcaliber/chat-switchboard/issues/69))
+- [x] Audit log entry on fallback fire: `action = "role.fallback"` with primary/fallback model IDs and error string
+- [x] `role.fallback` WebSocket event via EventBus (`PublishAsync`, zero latency impact on completion path)
+- [x] In-memory cooldown on `Resolver` (per-role, 5-minute TTL) to deduplicate repeated fallback alerts
+- [x] Admin UI: persistent alert banner on `role.fallback` event (persists until dismissed)
+- [x] Wire `*events.Bus` into `roles.NewResolver` via `.WithBus()` builder
+
+**QOL / UX Wins**
+- [x] **Chat rename**: inline edit on sidebar item — dblclick title → input → blur/Enter saves via `API.updateChannel(id, { title })`
+- [x] **Chat token count**: display `Tokens.estimateConversation()` in model bar, update on `selectChat` and after each message
+- [x] **State restore on refresh**: persist `App.currentChatId` to `sessionStorage` on select, restore on load
+- [x] **Utility model auto-naming**: after first assistant response, background utility role request → `POST /channels/:id/generate-title` → re-render sidebar. Fallback to truncation when no utility model configured. Debounced via `_autoNamePending` set
+- [x] **SW extension cache fix**: exclude `/extensions/` from service worker fetch handler
+- [x] **Mermaid renderer**: promoted enhanced version (v2.0 — pan/zoom, SVG/PNG export, source copy) to `extensions/builtin/mermaid-renderer/`
+
+---
+
+## v0.17.1 — SQLite Backend ✅
+
+Dual-database support. Every subsequent schema change is developed
+against both Postgres and SQLite from day one — no retrofit. SQLite
+enables single-binary deployment for dev, demo, edge, and single-user.
+
+Depends on: v0.17.0 DB debt cleanup (store layer is sole DB interface).
+
+**Store Layer**
+- [x] 19 SQLite store implementations covering all domain interfaces
+- [x] `DB_DRIVER` env var: `postgres` (default) | `sqlite`
+- [x] Separate migration files per driver (`migrations/sqlite/`)
+- [x] WAL mode + single-writer connection pooling for SQLite concurrency
+- [x] CI matrix: full handler integration tests against both Postgres and SQLite
+
+**Vector Search**
+- [x] App-level cosine similarity in Go (pure Go, no CGO/sqlite-vec required)
+- [x] Embeddings stored as JSON text in `kb_chunks.embedding` column
+- [x] Full feature parity with pgvector: `SimilaritySearch`, `InsertChunks`
+- [x] Graceful: adequate performance for SQLite-scale deployments (single-user, not millions of chunks)
+
+**Schema Compatibility**
+- [x] UUID generation: application-side `store.NewID()` (Go `uuid.New()`)
+- [x] JSONB → JSON text columns with `ToJSON()`/`ScanJSON()` helpers
+- [x] `UUID[]` arrays → JSON arrays with `ToJSONArray()`/`ScanJSONArray()`
+- [x] `TIMESTAMPTZ` → SQLite `TEXT` with `datetime('now')`
+- [x] `ON CONFLICT excluded.*` pattern (works in both dialects)
+- [x] `INSERT RETURNING id` → separate query pattern for SQLite
+
+**Test Infrastructure**
+- [x] `dialectSQL()` converts `$N` → `?` and strips `::jsonb` at runtime
+- [x] `database.PH(n)` returns dialect-appropriate placeholder
+- [x] `database.TruncateAll()` dialect-aware (DELETE + PRAGMA vs TRUNCATE CASCADE)
+- [x] Generic provider config: `PROVIDER`/`PROVIDER_KEY`/`PROVIDER_URL` (replaces `VENICE_API_KEY`)
+- [x] Model selection prefers non-reasoning models in live tests
+
+**What SQLite mode skips** (feature-gated, not broken):
+- [x] `LISTEN/NOTIFY` — WebSocket event fan-out uses in-process EventBus (already works)
+- [x] Full-text search `tsvector` — conversation_search uses LIKE fallback
+
+---
+
+## v0.17.2 — CodeMirror 6 Integration ✅
+
+Rich editor infrastructure for the frontend. CM6 is ESM-native; the build
+step runs in Docker (esbuild → single IIFE bundle). No change to dev
+experience for non-editor code — the rest of `src/js/` stays vanilla.
+
+Depends on: nothing (frontend-only). Prerequisite for: extension surfaces
+(v0.21.5 editor surface). See [DESIGN-CM6.md](DESIGN-CM6.md) for full spec.
+
+**Build Pipeline**
+- [x] `src/editor/` directory: `package.json`, `build.mjs`, `index.mjs`, language/theme modules
+- [x] `scripts/build-editor.sh`: shared build script for both Dockerfiles and local dev
+- [x] New Docker stage (`cm6-build`): `npm ci` + `node build.mjs` → `vendor/codemirror/`
+- [x] Both `Dockerfile.frontend` and `Dockerfile` (unified) use the shared build script
+- [x] Bundle output: `codemirror.bundle.js` (~295KB min, ~90KB gzip)
+- [x] Graceful degradation: all integration points check `window.CM` — falls back to `<textarea>` if bundle unavailable
+
+**Languages (bundled)**
+- [x] Markdown, JavaScript, JSON, SQL, HTML, CSS, YAML, Go, Python, Rust
+- [x] Additional modes: one-line import + rebuild
+
+**Phase 1: Extension Editor** (admin panel)
+- [x] `CM.codeEditor()` factory: line numbers, bracket matching, auto-indent, search/replace
+- [x] Replace manifest `<textarea>` → CM6 JSON mode
+- [x] Replace script `<textarea>` → CM6 JavaScript mode
+- [x] Remove manual Tab-key handler in `admin-handlers.js` (CM6 handles it)
+- [x] Update `saveAdminExtension()` to use `.getValue()`
+
+**Phase 2: Chat Input** (markdown mode)
+- [x] `CM.chatInput()` factory: markdown highlighting, minimal chrome (no line numbers, no gutter)
+- [x] Enter=send, Shift+Enter=newline keybindings
+- [x] Auto-growing height, placeholder text
+- [x] Wire `onChange` → `updateInputTokens()`
+- [x] Update `chat.js`, `attachments.js`, `tokens.js` to use CM API
+- [x] WYSIWYG fenced code block decorations (visual container matching claude.ai UX)
+- [x] Inline code shortcut (Ctrl/Cmd+E)
+
+**Phase 3: Polish**
+- [x] Theme integration: CSS variable overrides (`--bg`, `--border`, `--accent`, etc.)
+- [x] Dark/light/system mode toggle in appearance settings
+- [x] Vim/Emacs keybinding preference in appearance settings (`@replit/codemirror-vim`, `@replit/codemirror-emacs`)
+- [x] Vim/Emacs applies to code editor + extension editor only (never chat input)
+- [x] SW cache: exclude `vendor/codemirror/` with version bust
+- [x] Update `debug.js` snapshot to include CM6 version
+- [x] Documentation in ARCHITECTURE.md
+
+**CI/CD**
+- [x] Path-based change detection gating (FE-only → skip BE tests, docs-only → skip all)
+
+---
+
+## v0.17.3 — Notes Graph + Wikilinks ✅
+
+Knowledge graph and bi-directional linking for the notes system. Transforms
+notes from flat documents into an interconnected knowledge base with
+Obsidian-style `[[wikilinks]]`, backlinks, graph visualization, and
+transclusion.
+
+Depends on: CodeMirror 6 (v0.17.2), Notes CRUD (v0.13.x). See
+[DESIGN-0.17.3.md](DESIGN-0.17.3.md) for full spec.
+
+**Backend: Note Links**
+- [x] `note_links` table (Postgres + SQLite migrations)
+- [x] `NoteLinkStore` interface + both implementations
+- [x] `ExtractWikilinks()` regex parser + tests
+- [x] Link extraction on note create/update
+- [x] Dangling link resolution on note create
+- [x] `notes.source_message_id` column for chat-to-note provenance
+
+**API Endpoints**
+- [x] `GET /notes/:id/backlinks` — notes linking to this note
+- [x] `GET /notes/search-titles?q=` — lightweight fuzzy search for autocomplete
+- [x] `GET /notes/graph` — full graph topology (nodes + edges + unresolved)
+
+**CM6 Note Editor**
+- [x] `note-editor.mjs` factory: markdown live preview (heading sizes, blockquotes, code blocks)
+- [x] `wikilink.mjs` CM6 extension: parse, decorate as clickable chips, autocomplete on `[[`
+- [x] Textarea → CM6 swap in `notes.js` with graceful fallback
+- [x] `noteEditorTheme` in `theme.mjs`
+
+**Graph Visualization**
+- [x] Canvas-based force-directed graph (~200 lines, no d3 dependency)
+- [x] O(n²) Coulomb repulsion + Hooke spring + center gravity
+- [x] Pan, zoom (0.15–4.0x), drag nodes, hover highlight, click to open
+- [x] Node sizing by link_count, folder-based coloring
+- [x] Ghost nodes for unresolved `[[links]]` with toggle
+- [x] Energy-based pause (stop rAF below KE threshold)
+- [x] ResizeObserver for responsive canvas
+
+**Note-from-Selection + Daily Notes**
+- [x] "Note" button in message action bar
+- [x] Selection-aware capture (`window.getSelection()` within message)
+- [x] Provenance tracking (`source_channel_id` + `source_message_id`)
+- [x] "Today" button → find-or-create daily note in `/daily/`
+
+**Read Mode**
+- [x] `[[link]]` rendered as clickable wikilink chips
+- [x] `![[embed]]` transclusion with async content fetch, recursion guard
+- [x] Backlinks panel (collapsible, with count badge)
+
+---
+
+## v0.18.0 — Memory (User + Persona Scopes) ✅
+
+Long-term memory across conversations, with scope-aware isolation.
+Unlike KB (static documents) or compaction (within-conversation), this
+captures facts and preferences that persist across channels.
+
+**Key differentiator: Persona-scoped memory.** Each Persona can build
+its own memory independently of user memory, preventing cross-context
+contamination and enabling specialized knowledge accumulation.
+
+Depends on: compaction (v0.15.0), knowledge bases (v0.14.0), persona-KB binding (v0.17.0), SQLite backend (v0.17.1).
+
+See [DESIGN-0.18.0.md](DESIGN-0.18.0.md) for full spec.
+
+**Memory Scopes**
+- [x] `user` — personal facts/preferences, persists across all conversations (current industry standard)
+- [x] `persona` — shared across all users of that Persona, accumulated from conversations (differentiator)
+- [x] `persona+user` — per-user within a Persona context (e.g. tutoring progress per student)
+- [x] Configurable per Persona: which scopes are active, whether user memory is passed through
+
+**Data Model**
+- [x] `memories` table: `id`, `scope` (user, persona, persona_user), `owner_id` (user_id or persona_id), `user_id` (nullable — for persona+user scope), `key`, `value`, `source_channel_id`, `confidence` (float), `status` (active, pending_review, archived), `created_at`, `updated_at`
+- [x] Index on `(scope, owner_id, user_id)` for fast lookup
+- [x] Embedding column (`vector(3072)`) for semantic memory search
+
+**Tools**
+- [x] `memory_save` tool: LLM explicitly stores a fact
+    - Scope-aware: saves to the active memory scope for the current Persona context
+    - Structured: `key` (short label) + `value` (detail) + `confidence`
+- [x] `memory_recall` tool: LLM queries stored facts relevant to current context
+    - Merges results from applicable scopes (user + persona + persona+user)
+    - Semantic search via embeddings + keyword fallback
+
+**Automatic Extraction**
+- [x] Background job: post-conversation analysis identifies memorable facts (opt-in)
+- [x] Configurable extraction prompt per Persona (e.g. "extract FAQ-worthy Q&A pairs")
+- [x] Extracted memories start in `pending_review` status
+
+**Review Pipeline**
+- [x] Admin/team admin review queue: pending memories with approve/reject/edit
+- [x] Persona memory review: team admins see what Personas are "learning"
+- [x] User memory review: users see their own memories in Settings
+
+**Memory Injection**
+- [x] At completion time: inject relevant memories into system prompt
+- [x] Context budget aware: limit injected memory tokens
+- [x] Scope priority: persona+user > persona > user (most specific wins on conflicts)
+
+**Use Cases**
+- [x] Helpdesk Persona: builds FAQ from repeated questions, human-reviewable
+- [x] Roleplay Persona: isolated memory prevents tone/context bleeding from user's other conversations
+- [x] Tutoring Persona: tracks per-student progress, common misconceptions
+- [x] Sales Persona: accumulates objection responses from real conversations
+- [x] Onboarding Persona: learns what new hires commonly struggle with
+
+**User Controls**
+- [x] Settings → Memory: view, edit, delete personal memories
+- [x] Per-Persona memory toggle: "Allow this persona to remember things about me"
+- [x] Admin: enable/disable, retention policies, per-team scoping
+- [x] Privacy: user memories never cross team boundaries; persona memories respect group access
+
+---
+
+## v0.18.1 — Side Panel Architecture ✅
+
+Refactored the side panel from a shared-tab layout to independent
+single-slot panels. Any action fills the slot, replacing whatever was
+there — no tabs, no association between panel types. Extension UI
+primitives give browser extensions safe access to host app features.
+
+Depends on: Notes graph + wikilinks (v0.17.3). Prerequisite for: live
+collaboration (v0.23.0) where multiple panels need simultaneous visibility.
+
+**Panel System**
+- [x] Panel registry: named panels with independent open/close state
+- [x] Single-slot model: action-driven, each open replaces the previous
+- [x] Dual-view mode: two panels side-by-side (configurable split ratio via drag divider)
+- [x] Panel-persistent state: each panel remembers scroll position, open note, etc.
+- [x] Header label shows active panel name (replaces tab bar)
+- [x] Keyboard shortcut: Ctrl/Cmd+\ cycles panels, Ctrl/Cmd+Shift+\ toggles dual
+
+**Preview Panel**
+- [x] Dedicated preview panel (independent of Notes)
+- [x] HTML/document preview with iframe sandbox
+- [x] Code output preview (extension-rendered blocks via pop-out)
+- [x] Live-updating during streaming responses (500ms debounce)
+
+**Extension UI Primitives**
+- [x] `ctx.ui.toast()` — toast notifications
+- [x] `ctx.ui.openPreview()` — load HTML into side panel preview
+- [x] `ctx.ui.isDark()` — theme detection
+- [x] `ctx.ui.isMobile()` — viewport width check
+- [x] `ctx.ui.isPanelOpen()` — side panel visibility
+- [x] `ctx.ui.confirm()` — modal confirm dialog
+- [x] Mermaid extension refactored to use primitives exclusively (zero direct globals)
+- [x] Context-aware expand: single button, fullscreen or side panel pop-out
+
+**Mobile**
+- [x] Swipe navigation between panels
+- [x] Tap-to-close overlay
+- [x] Graceful collapse to single-panel on narrow viewports
+- [x] Enlarged touch targets, fullscreen close button (40px desktop, 48px mobile)
+
+---
+
+## ✅ v0.19.0 — Projects / Workspaces
+
+Organizational containers that group related conversations, KBs, and
+notes into a single workspace with shared access controls.
+
+Depends on: user groups (v0.16.0), knowledge bases (v0.14.0).
+
+**Data Model**
+- [x] `projects` table: `id`, `name`, `description`, `color`, `icon`, `scope` (personal/team/global), `owner_id`, `team_id`, `is_archived`, `settings` (JSONB)
+- [x] `project_channels` junction: ordered membership with UNIQUE `channel_id`, denormalized FK on `channels.project_id`
+- [x] `project_knowledge_bases` junction: with `auto_search` flag
+- [x] `project_notes` junction
+- [x] `resource_grants` CHECK extended to include `'project'`
+
+**Features**
+- [x] Channels can belong to a project (optional `project_id` FK)
+- [x] KBs can belong to a project → auto-linked to all channels in the project (BuildKBHint + kbsearch)
+- [x] Notes can belong to a project → auto-associated when created from project channel
+- [x] KB resolution chain: Persona → Project → Channel → Personal
+- [x] Project sidebar section: collapsible groups above time-based Recent section
+
+**UI**
+- [x] Sidebar: projects as collapsible groups with color dots, counts, options menu
+- [x] Right-click context menu: move chat to project / remove / create-and-assign
+- [x] Drag-and-drop channels between project groups and Recent
+- [x] New Project button in split dropdown
+- [x] Channel list `project_id` filter (`?project_id=uuid` or `?project_id=none`)
+- [x] Collapse state persisted in localStorage
+
+**Deferred to later versions:**
+- Project creation dialog (name, description, default Persona, default KBs) — using prompt() for now
+- ~~Project detail panel (KB + note management within a project)~~ → v0.19.1
+- ~~Project-level Persona default~~ → v0.19.2
+- Folders within projects
+- Project templates
+- Admin-level team/global project management
+- Project-specific files (full project-level upload — deferred for proper architecture)
+- Notifications (moved to v0.20.0)
+
+---
+
+## ✅ v0.19.1 — Active Project + Project System Prompt + Detail Panel
+
+Quality-of-life improvements making projects usable for daily workflow.
+No migrations.
+
+Depends on: v0.19.0 Projects/Workspaces.
+
+**Active Project**
+- [x] Pin a project as active — new chats auto-assign via `addChannelToProject` after channel creation
+- [x] `App.activeProjectId` persisted in `localStorage('cs-active-project')`
+- [x] Visual indicator: `.project-group.active` accent border + 📌 icon
+- [x] Toggle from project ⋯ menu ("Pin as active" / "Unpin project")
+- [x] Cleared on project delete
+
+**Project System Prompt**
+- [x] Per-project instructions in `projects.settings` JSONB (`system_prompt` key)
+- [x] Injected in `loadConversation` between persona/channel prompt and KB hint
+- [x] Merge semantics on update: reads existing JSONB, overlays patch keys, writes back
+- [x] Both Postgres and SQLite stores updated
+
+**Project Detail Panel**
+- [x] Registered with `PanelRegistry` (same pattern as Notes, Preview)
+- [x] System prompt textarea with Save button
+- [x] KB management: list with names (LEFT JOIN), [+ Add] picker dropdown, [✕] remove
+- [x] Notes list with titles (LEFT JOIN), [✕] unbind
+- [x] Accessible from project ⋯ menu → "Project settings"
+
+**Bug Fixes**
+- [x] `renderChatList` early return prevented project groups from rendering when zero chats
+- [x] Recent section drop target: "Drop chats here to unassign" hint with `min-height: 40px`
+
+---
+
+## ✅ v0.19.2 — Project Persona Default + Archive + Channel Reorder
+
+Completes the project management feature set. No migrations.
+
+Depends on: v0.19.1.
+
+**Project Persona Default**
+- [x] Bind a persona to a project via detail panel dropdown
+- [x] Stored in `projects.settings.persona_id`
+- [x] Resolution chain: explicit `req.PresetID` → project persona → none
+- [x] Inherits model, provider config, temperature, max tokens, system prompt as defaults
+
+**Project Archive Toggle**
+- [x] Checkbox in project detail panel
+- [x] Archived projects hidden from sidebar by default
+- [x] "▸ Show archived (N)" toggle button below project list
+- [x] Chats in hidden-archived projects spill into Recent section (never vanish)
+- [x] Dimmed + italic visual treatment for archived groups
+
+**Channel Reorder**
+- [x] `loadProjectChannelPositions()` fetches server-persisted positions on startup
+- [x] `_getReorderedProjectChats()` sorts project chats by stored position
+- [x] Right-click context menu: ↑ Move up / ↓ Move down (optimistic swap + API call)
+- [x] Order maintained across add/remove/move operations
+
+---
+
+## v0.20.0 — Notifications + @mention Routing + Multi-model ✅
+
+Notification infrastructure that makes collaboration real-time, plus
+multi-model routing for channels. Three-phase delivery: notifications
+core (in-app), @mention parsing + fan-out completions, email transport
++ per-user notification preferences.
+
+_(Notifications shifted from v0.19.0; @mention routing shifted from v0.17.0)_
+
+Depends on: v0.19.2 (Projects complete), EventBus + WebSocket hub (v0.9.x),
+`channel_models` table (v0.16.0 schema). See
+[DESIGN-0.20.0.md](DESIGN-0.20.0.md) for full spec.
+
+**Phase 1 — Notifications Core (in-app)**
+- [x] `notifications` table: `id`, `user_id`, `type`, `title`, `body`, `resource_type`, `resource_id`, `is_read`, `created_at` (Postgres + SQLite migrations)
+- [x] `NotificationStore` interface + both implementations: Create, ListByUser (paginated), MarkRead, MarkAllRead, Delete, UnreadCount
+- [x] `notifications.Service` with `Notify()` / `NotifyMany()` — centralized creation + WebSocket dispatch
+- [x] EventBus routes: `notification.new`, `notification.read` (badge sync across tabs)
+- [x] API endpoints: list, unread-count, mark-read, mark-all-read, delete (5 endpoints, all user-scoped)
+- [x] Initial sources: `role.fallback` (EventBus subscription), `kb.ready`/`kb.error`, `grant.changed`
+- [x] Frontend: bell icon + unread badge (capped 9+), notification dropdown (latest 10, click-to-navigate), full panel via PanelRegistry
+- [x] WebSocket handler: real-time push + toast for high-priority types
+- [x] Background cleanup goroutine (configurable retention, default 90 days)
+
+**Phase 2 — @mention Parsing + Multi-model Routing**
+- [x] `mentions.Parse()`: extract @mentions, resolve against channel model roster (case-insensitive, longest-match-first, trailing punctuation tolerant)
+- [x] Parser tests: no mentions, unresolved, multiple, overlapping names, punctuation edge cases
+- [x] Channel model CRUD handlers (4 endpoints: list, add, remove, update)
+- [x] Completion handler: mention extraction → target resolution → sequential fan-out → N assistant messages
+- [x] SSE streaming: model attribution in delta events (`model_display` field)
+- [x] Frontend: model pills in chat header with add/remove UI
+- [x] Frontend: @mention autocomplete via CM6 `mentionCompletion` extension (roster-backed)
+- [x] Frontend: model attribution labels on multi-model assistant messages
+- [x] Backward compat: channels with no extra `channel_models` rows work exactly as before
+
+**Phase 3 — Email Transport + Notification Preferences**
+- [x] `notification_preferences` table (Postgres + SQLite): per-user, per-type in_app/email toggles
+- [x] Preference resolution chain: specific type → user wildcard `*` → system default (in_app=true, email=false)
+- [x] `EmailTransport`: SMTP with implicit TLS (port 465) and STARTTLS (port 587), multipart MIME (HTML + plaintext)
+- [x] Email templates: branded HTML + plaintext, domain-prefixed subjects, Go `html/template`
+- [x] Preference CRUD endpoints (3: list, set with partial patch, delete)
+- [x] Admin SMTP configuration: enable toggle, host/port/user/password/from/TLS fields, test email button
+- [x] User notification preferences UI (Settings → Notifications tab, per-type checkboxes)
+- [x] Notification service: preference check before dispatch, async email delivery (goroutine, 30s timeout)
+- [x] Tests: preference resolution chain (7 tests), email templates (4 tests)
+- [x] Deferred: digest mode (batched email), SMTP password vault encryption
+
+**Hotfix (carried forward from v0.19.2 investigation)**
+- [x] `user_model_settings` NULL scan fix: COALESCE on `hidden`/`sort_order` in SELECT + INSERT for both dialects
+- [x] Gin release mode: auto-set `gin.ReleaseMode` when `ENVIRONMENT=production`, suppress health check log spam
+
+---
+
+## v0.21.x — Workspace Platform + Extension Surfaces
+
+Seven-release series decomposing workspace storage, tools, indexing, git,
+surface infrastructure, and editor/article modes. Full specification in
+[DESIGN-0.21.0.md](DESIGN-0.21.0.md).
+
+Depends on: file storage (v0.12.0), extension foundation (v0.11.0),
+CodeMirror 6 (v0.17.2), knowledge base embedding pipeline (v0.14.0).
+
+### v0.21.0 — Workspace Storage Primitive ✅
+
+Pure backend foundation. Workspaces as a polymorphic platform primitive
+owned by users, projects, channels, or teams. Dual-layer storage: PVC
+filesystem (source of truth) + DB metadata index (queryable cache).
+
+- [x] `workspaces` table: polymorphic owner (user/project/channel/team), root_path, max_bytes quota, status
+- [x] `workspace_files` table: metadata index (path, MIME type, size, sha256, is_directory)
+- [x] `WorkspaceStore` interface: CRUD, file index (upsert/delete/list/prefix), ownership lookup, stats
+- [x] Postgres + SQLite store implementations with upsert-on-conflict for file index
+- [x] `workspace.FS` package: read, write (atomic via temp+rename), delete, mkdir, stat, list, reconcile (FS→DB sync)
+- [x] `workspace.Archive`: zip/tar.gz extract + create with archive bomb protection (10K file limit, 100MB single file, quota enforcement), common-prefix stripping
+- [x] Content type detection: extension-based (40+ source code types) with http.DetectContentType fallback
+- [x] SHA256 computed during write via tee reader (enables content-addressed skip in v0.21.2)
+- [x] Path traversal guards: cleanPath + absPath validation, symlink rejection
+- [x] 15 API endpoints: workspace CRUD, file CRUD, archive upload/download, reconcile, stats
+- [x] Owner-based authorization: user=self, channel=owner, project=member, team=member
+- [x] Unit tests: path cleaning, traversal detection, MIME detection, unsafe path filtering, write/read round-trip, delete, mkdir
+
+### v0.21.1 — Workspace Tools + Channel/Project Binding ✅
+
+Make workspaces useful in chat mode via tool calls.
+
+- [x] Workspace tools (category: workspace): `workspace_ls`, `workspace_read` (50KB soft limit), `workspace_write` (auto-mkdir), `workspace_rm` (recursive guard), `workspace_mv`, `workspace_patch` (find/replace)
+- [x] `channels.workspace_id` FK, `projects.workspace_id` FK
+- [x] Workspace resolution: channel workspace → project workspace (override pattern)
+- [x] Tool injection in completion handler when workspace bound
+- [x] Frontend: deferred (channel settings workspace toggle, project Files tab, chat bar workspace indicator)
+
+### v0.21.2 — Workspace Indexing + Semantic Search ✅
+
+Embed text files for semantic search. Reuses `knowledge.SplitText` + `knowledge.Embedder`.
+
+- [x] `workspace_chunks` table (Postgres + SQLite migrations)
+- [x] `workspace_files` additions: `index_status`, `chunk_count` columns
+- [x] `workspaces.indexing_enabled` boolean (default true)
+- [x] Store methods: `InsertChunks`, `DeleteChunksByFile`, `SimilaritySearch`, `UpdateFileIndexStatus`
+- [x] Indexable types: text MIME types + 40+ code extensions + special filenames (Makefile, Dockerfile, etc.)
+- [x] Code-aware chunking: 1500-char chunks with function/class/type/sub boundary separators
+- [x] Content-addressed skip: sha256 comparison before re-chunking/re-embedding
+- [x] `workspace.Indexer`: background goroutine with configurable concurrency semaphore
+- [x] Single-file indexing via `FS.WriteFile` hook (`SetIndexer`)
+- [x] Batch indexing via `ExtractArchive` (sequential within one semaphore slot)
+- [x] `workspace_search` tool: semantic search with optional glob filtering, top-K capped at 20
+- [x] `GET /api/v1/workspaces/:id/index-status` endpoint (per-status file counts, total chunks)
+- [x] Configuration: `WORKSPACE_INDEXING_ENABLED`, `WORKSPACE_INDEX_CONCURRENCY` env vars
+- [x] Graceful degradation when no embedding role configured
+- [x] Mock store updated for FS unit tests
+
+### v0.21.3 — Surface Infrastructure + REPL ✅
+
+Pure UI architecture. No workspace dependency (parallel development).
+
+- [x] `data-surface-region` attributes on index.html containers (surface-header, surface-main, surface-footer, sidebar-content)
+- [x] `surfaces.js` — SurfaceRegistry: register, activate, deactivate, getCurrent, list
+- [x] `ctx.ui.replace()` / `ctx.ui.restore()` with DOM preservation (DocumentFragment-based)
+- [x] `ctx.surfaces.register()` API for extensions
+- [x] Mode selector component in sidebar (`#modeSelectorWrap`, auto-shown when ≥2 surfaces)
+- [x] Chat as default surface (implicit, always registered)
+- [x] `surface.activated` / `surface.deactivated` / `surface.registered` / `surface.unregistered` EventBus events
+- [x] REPL tab: AsyncFunction wrapper, global injection (API, Events, Extensions, Surfaces, DebugLog, Panels, UI, $, $$, sleep)
+- [x] REPL tab: pretty-print results (collapsible JSON, type-colored primitives, DOM element summaries)
+- [x] REPL tab: command history (sessionStorage, ↑/↓ navigation)
+- [x] REPL tab: tab-completion on object graphs, event labels, globals
+- [x] REPL tab: event label hints (Events.on/emit completion)
+- [x] REPL tab: admin gate (admin role OR ?debug=1 URL param)
+- [x] REPL tab: toolbar (clear, copy, help)
+- [x] CSS: mode selector + REPL styles
+- [x] Documentation in EXTENSIONS.md §6 updated with implementation details
+- [ ] Mobile: mode selector collapses to hamburger/bottom nav — moved to v0.22+
+- [ ] Integration with extension loader (surfaces from manifest — moved to v0.22+)
+
+### v0.21.4 — Git Integration ✅
+
+Layer git operations onto workspaces.
+
+- [x] `workspaces` additions: git_remote_url, git_branch, git_credential_id, git_last_sync
+- [x] `git_credentials` table: auth_type (https_pat/https_basic/ssh_key), encrypted_data (AES-256-GCM)
+- [x] Postgres migration (012_v0214_git.sql) + SQLite migration (011_v0214_git.sql)
+- [x] `models.GitCredential`, `GitCredentialSummary`, `GitStatus`, `GitFileStatus`, `GitLogEntry`
+- [x] `GitCredentialStore` interface + Postgres/SQLite implementations (Create, GetByID, ListByUser, Delete)
+- [x] `workspace.GitOps` with exec-based git operations (9 operations)
+- [x] Credential injection: temp `GIT_ASKPASS` (PAT), `.git-credentials` (basic), `GIT_SSH_COMMAND` (SSH)
+- [x] Security: reject file:// URLs, sanitize error output, GIT_TERMINAL_PROMPT=0
+- [x] Clone, Pull, Push, Status, Diff, Commit, Log, BranchList, Checkout
+- [x] `SetGitLastSync` on WorkspaceStore interface + both implementations
+- [x] Post-operation reconcile + re-index hook (clone, pull, checkout)
+- [x] 5 git tools: git_status, git_diff, git_commit, git_log, git_branch
+- [x] Git tools filtered out when no workspace bound (completion handler)
+- [x] 9 git API endpoints on /api/v1/workspaces/:id/git/*
+- [x] 3 credential CRUD endpoints on /api/v1/git-credentials
+- [x] Wired in main.go: GitOps creation, tool registration, route registration
+- [ ] Workspace settings UI: git config section — moved to v0.22+
+- [ ] User Settings: git credentials management UI — moved to v0.22+
+- [ ] Integration tests: clone, commit, push/pull cycle (requires git binary in CI)
+- [ ] `.gitignore` respect in workspace indexing — moved to v0.22+
+
+### v0.21.5 — Editor Surface (Development Mode) ✅
+
+IDE-like experience. Browser-tier surface consuming workspace primitives.
+
+- [x] Layout: file tree (sidebar), code editor (CM6, main), AI chat panel (resizable split), status bar
+- [x] File tree: workspace_ls backed, context menu (open, delete), nested directory expansion, file icons
+- [x] Code editor: CM6 codeEditor() factory with textarea fallback, language auto-detection (20+ languages), tab bar, Ctrl+S save
+- [x] AI chat panel: same channel context via Surfaces DOM borrowing, live update via workspace.file.changed event
+- [x] Keyboard shortcuts: Ctrl+P quick open, Ctrl+S save, Ctrl+W close tab
+- [x] Split pane layout with draggable resize handle
+- [x] Status bar: file path, language mode, git branch
+- [x] Workspace API methods on frontend (8 methods)
+- [x] Surfaces.getSavedFragment/putSavedFragment for cross-surface DOM sharing
+- [x] workspace.file.changed event emission from stream_loop.go after tool calls
+- [x] Event route table: workspace.file. → DirToClient
+- [x] editor-mode.css: dark theme, mobile responsive (stacked at ≤768px)
+- [x] Auto-registration: surface registers when channel/project has workspace binding
+- [x] Workspace management UI: create, list, bind from project settings + chat context menu
+- [x] GET /workspaces list endpoint, workspace_id in channel API (update, get, list)
+- [x] Git status indicators in file tree (M/A/U badges + colors) — closed in v0.21.6
+- [ ] Drag-drop file reorder — moved to v0.22+
+- [x] Ctrl+Shift+F workspace search (maps to quick open) — closed in v0.21.6
+- [x] Auto-save on tab/mode switch — closed in v0.21.6
+
+### v0.21.6 — Article Surface + Document Output Pipeline ✅
+
+Writing-focused surface. Document is artifact, conversation is secondary.
+
+- [x] Layout: outline (sidebar top), AI assistant (sidebar bottom), rich text editor (CM6 markdown, main)
+- [x] Outline: auto-generated from headings, click-to-scroll (navigates CM6 cursor)
+- [x] Rich text editor: CM6 codeEditor() markdown mode, line wrapping, centered content (720px max), textarea fallback
+- [x] AI assistant: chat panel embedded in sidebar via Surfaces DOM borrowing
+- [x] Export dropdown: Download Markdown, Download HTML (via marked.js + DOMPurify), Copy to clipboard
+- [x] Document picker: lists .md/.mdx/.txt files from workspace, create new document inline
+- [x] Focus mode: dims non-active lines in editor (CM6 opacity-based, toggle button)
+- [x] Word count + reading time in status bar (~230 wpm)
+- [x] Auto-save: debounced (2s) on content change, save on tab switch / surface deactivate
+- [x] Live update on workspace.file.changed event (reloads if file unmodified)
+- [x] Surface registration: registers as "Article" with file-text icon when workspace bound
+- [x] article-mode.css: outline styling, export menu, focus mode, mobile responsive
+- [x] (from v0.21.5 deferred) Git status indicators in editor file tree (M/A/U badges + colors)
+- [x] (from v0.21.5 deferred) Auto-save on tab/mode switch in editor surface
+- [x] (from v0.21.5 deferred) Ctrl+Shift+F workspace search (maps to quick open)
+- [ ] Article-specific AI tools (suggest_outline, expand_section, check_citations) — moved to v0.22+
+- [ ] Drag-to-reorder outline sections — moved to v0.22+
+- [ ] PDF export via pandoc — moved to v0.22+
+
+#### Bugfixes & DX (added post-initial)
+
+- [x] Hash Router (`router.js`): URL-driven direct-to-surface navigation (#/chat, #/editor, #/article). Bookmarkable, back/forward works. Precursor to Go `html/template` server-rendered pages (v0.25.0) for public/workflow entry points.
+- [x] `openDirect(wsId)` on EditorMode + ArticleMode: bypass check(), register directly with workspace ID
+- [x] Workspace picker overlay: shown when navigating to surface without workspace, auto-selects if only one
+- [x] `SEED_PROVIDERS` env var: auto-creates global providers on startup (dev/test only, idempotent)
+- [x] Mode selector labels: icon + text, labels hide when sidebar collapsed
+- [x] `chat.switched` / `chat.created` events: wired into selectChat(), newChat(), sendMessage()
+- [x] `workspace_id` in channel API responses: added to list/get/create for both SQLite and Postgres
+- [x] Frontend chat + project objects: now carry `workspace_id` for Router and surface check() optimization
+
+---
+
+### v0.21.7 — Bugfix: scanJSON Driver Buffer Aliasing ✅
+
+Critical fix for intermittent 500 errors on paginated list endpoints.
+
+- [x] `scanJSON` []byte path: copy driver buffer instead of aliasing (`json.RawMessage(v)` → `make+copy`)
+- [x] `CreateChannel` Postgres RETURNING path: use `scanJSON(&ch.Settings)` instead of bare `&ch.Settings`
+- [x] `UpdateChannel` settings write: validate `json.Valid()` before JSONB merge, reject with 400
+- [x] New tests: `TestScanJSON_ByteSliceNotAliased`, `TestScanJSON_ByteSliceIsolation_MultiRow`
+
+**Root cause:** `json.RawMessage(v)` is a type conversion, not a copy — it aliases
+the `[]byte` buffer owned by `database/sql`. Per the `Scanner` interface docs, `[]byte`
+values are only valid until the next `rows.Scan()` call. In paginated list endpoints,
+row N's Settings slice header pointed into memory that row N+1's scan overwrote,
+producing corrupt JSON that passed `json.Valid()` at scan time but failed at marshal
+time when `SafeJSON` serialized the full response.
+
+---
+
+## v0.22.0 — Provider Health + Capability Overrides ✅
+
+Smallest shippable unit that unblocks routing. Track provider error rates
+and latency, add admin override layer for model capabilities.
+
+Depends on: usage tracking (v0.10.0), capabilities resolver (v0.9.1).
+
+**Provider Health Tracking**
+- [x] `provider_health` table: `provider_config_id` FK, `window_start` (hourly buckets), `request_count`, `error_count`, `timeout_count`, `total_latency_ms`, `max_latency_ms`, `last_error`, `last_error_at`
+- [x] In-memory health accumulator: goroutine-safe counters per provider, flushed to DB on interval (60s)
+- [x] `RecordSuccess`/`RecordError`/`RecordTimeout` called from completion handler after every provider call (sync + streaming)
+- [x] Provider status derivation: `healthy` / `degraded` / `down` based on error rate thresholds (5% = degraded, 25% = down)
+- [x] `GET /api/v1/admin/providers/:id/health` endpoint: current status + hourly windows (configurable hours param)
+- [x] `GET /api/v1/admin/providers/health` endpoint: summary status for all providers
+- [x] _(shipped v0.22.3)_ Health status included in `GET /api/v1/models/enabled` response (new `provider_status` field)
+- [ ] _(deferred → v0.22.2)_ Auto-disable: optional policy to mark provider inactive when `down` for N consecutive windows
+- [x] Background cleanup: prune health rows older than 7 days (6-hour cycle)
+
+**Capability Admin Overrides**
+- [x] `capability_overrides` table: `provider_config_id` (nullable for global), `model_id`, `field`, `value`, `set_by`, `created_at`
+- [x] Three-tier resolution in `ResolveIntrinsic()`: catalog → heuristic → **admin override** (highest priority)
+- [x] `PUT /api/v1/admin/models/:id/capabilities` endpoint: set individual capability overrides
+- [x] `DELETE /api/v1/admin/models/:id/capabilities/:overrideId` endpoint: remove override
+- [x] `GET /api/v1/admin/models/:id/capabilities` endpoint: show resolved caps with source annotation (catalog/heuristic/override)
+- [x] `GET /api/v1/admin/capability-overrides` endpoint: list all overrides
+- [x] Postgres + SQLite migrations (013_v0220_health.sql / sqlite 012_v0220_health.sql)
+
+**Search Provider Health** _(deferred → v0.22.1)_
+- [ ] `RecordOutcome` for web_search and url_fetch tool calls (search provider tracking)
+- [ ] Rate limit tracking per provider config (requests/minute counter in health accumulator)
+
+**Workspace Pane Refactor** (frontend)
+- [x] `.workspace` flex container replaces `.chat-area` + `.side-panel` layout
+- [x] `.workspace-primary` / `.workspace-secondary` independent pane model
+- [x] `.workspace-handle` drag-resize between panes (replaces old side-panel-resize)
+- [x] Surface layout declarations: `primary`, `secondary`, `secondaryOpts` per surface
+- [x] Dual-view mode removed (was `_dualMode`, `_splitRatio`, `_secondary` in PanelRegistry)
+- [x] Zoom selector updated for new class names
+
+**Bugfix (v0.21.7)**
+- [x] `scanJSON` driver buffer aliasing — copy `[]byte` from database driver instead of aliasing slice header
+- [x] `CreateChannel` RETURNING path uses `scanJSON(&ch.Settings)` instead of bare scan
+- [x] `UpdateChannel` validates `json.Valid()` on settings before JSONB merge
+
+---
+
+## v0.22.1 — Provider Extensions (Declarative Config) ✅
+
+Replace hardcoded provider-specific behavior with data-driven configuration.
+Same model, different provider → different parameters.
+
+Depends on: provider health (v0.22.0).
+
+**Provider Profiles**
+- [x] Profile schema per provider type: defines available settings, types, defaults, validation, dependency rules (`providers/profile.go`)
+- [x] Built-in profile schemas for: openai, anthropic, venice, openrouter (unknown types fall back to openai-compatible)
+- [x] System prompt injection: `system_prompt_prefix` setting prepended to first system message (all providers)
+- [x] Thinking mode toggle: Anthropic `extended_thinking` + `thinking_budget` → injects `thinking.type=enabled`; Venice `enable_thinking` → disables Venice system prompt
+- [ ] _(not needed)_ `provider_profiles` JSONB column — existing `provider_configs.settings` JSONB already serves this purpose
+
+**Request/Response Transforms**
+- [x] `Hooks.PreRequest(cfg, req)` — decorate request before dispatch (system prompt prefix, ExtraBody injection)
+- [x] `Hooks.PostStreamEvent(cfg, event)` — normalize provider-specific response fields (Venice thinking extraction)
+- [x] Hook implementations: Venice web search + thinking, Anthropic extended thinking + beta header, OpenRouter routing preferences + require_parameters, OpenAI frequency/presence penalty
+- [x] Preset-level overrides: `MergePresetSettings()` merges persona overrides onto provider settings, respecting `ProviderOnly` fields
+- [x] `ProviderConfig.Settings` fully utilized: hooks read from config, not hardcoded switch statements
+- [x] `CompletionRequest.ExtraBody` field + `mergeExtraBody()` for provider-specific wire fields
+- [x] Anthropic extended thinking stream support: `thinking_delta` content blocks → `Reasoning` field
+
+**Provider Type Registry**
+- [x] `providers.Init()` uses `RegisterType()` with full metadata (name, description, default endpoint, profile schema)
+- [x] `ProviderTypeMeta` struct: ID, name, description, default_endpoint, profile_schema
+- [x] `GET /api/v1/admin/provider-types` endpoint: list available provider types with their profile schemas
+- [ ] _(deferred → v0.23)_ New provider types registrable via config file (openai-compatible endpoint + custom profile schema)
+
+**Search Provider Health** (carried from v0.22.0)
+- [ ] _(deferred → v0.22.2)_ `RecordOutcome` for web_search and url_fetch tool calls
+- [ ] _(deferred → v0.22.2)_ Rate limit tracking per provider config
+
+---
+
+## v0.22.2 — Routing Policies + Fallback Chains ✅
+
+Rules-based routing engine — policy, not ML. Evaluated after `resolveConfig()`
+between "what model was requested" and "which provider serves it."
+
+Depends on: provider health (v0.22.0), provider extensions (v0.22.1).
+
+**Routing Policies**
+- [x] `routing_policies` table: `id`, `name`, `scope` (global/team), `team_id`, `priority` (lower wins), `policy_type`, `config` (JSONB), `is_active`
+- [x] Policy types: `provider_prefer` (ordered fallback list), `team_route` (restrict team to providers), `cost_limit` (heuristic cost cap), `model_alias` (alias → provider+model rewrite)
+- [x] Policy evaluator: takes requested model + user context → returns ranked list of `(providerConfigID, modelID)` candidates
+- [x] Integration point: `evaluateRouting()` called after resolveConfig, before provider dispatch — reloads winning config credentials on switch
+- [ ] _(deferred → v0.23)_ `capability_match` policy type ("cheapest model with tool_calling")
+
+**Fallback Chains**
+- [x] Fallback runner: `RunWithFallback()` tries candidates in order with configurable max retries
+- [x] Health-aware: skip providers with status `down`, prefer `healthy` over `degraded`
+- [x] All-down graceful degradation: keeps candidates rather than failing
+- [ ] _(deferred → v0.23)_ Latency-aware preference: track response time percentiles, prefer faster providers
+- [ ] _(deferred → v0.23)_ Cost-aware preference with budget ceiling per request
+
+**Routing Metadata**
+- [x] `X-Switchboard-Provider` response header: `providerID/configID` on every completion
+- [x] `X-Switchboard-Route` header: policy name when routing is active
+- [x] `routing_decision` JSONB column on `usage_log`
+- [x] `POST /api/v1/admin/routing/test` endpoint: dry-run policy evaluation with live health status
+- [x] Admin CRUD: GET/POST/PUT/DELETE `/api/v1/admin/routing/policies`
+
+---
+
+## v0.22.3 — Provider Admin UI + Deferred Polish ✅
 
 Admin interfaces for v0.22.0–v0.22.2 features, plus deferred items from v0.21.x.
 
-**Provider Health Dashboard**
-- Provider status badges, error rate/latency charts, refresh button
-- Health status in `GET /models/enabled` response
+Depends on: routing policies (v0.22.2).
 
-**Capability Override Editor**
-- Table of all overrides (model, config, field, value)
-- Delete per override
+**Admin UI**
+- [x] Provider health dashboard: status badges, error rate/latency/timeout metrics per provider, refresh button (`loadAdminHealth`)
+- [x] Capability override editor: table listing all overrides with model, config, field, value; delete button per row (`loadAdminCapabilities`)
+- [x] Routing policy builder: CRUD with name/priority/type/scope/team/config(JSON)/active toggle, dry-run test panel with candidate ranking and health status (`loadAdminRouting`, `_showRoutingForm`, `_runRoutingTest`)
+- [x] New "Routing" admin category with Health, Routing, and Capabilities sections
+- [x] Health status included in `GET /api/v1/models/enabled` response (`provider_status` field on UserModel)
+- [ ] _(deferred → v0.23)_ Provider profile editor: key-value config per provider type, preview of effective settings
+- [ ] _(deferred → v0.23)_ Fallback chain visualizer: drag-to-reorder provider priority per model family
 
-**Routing Policy Builder**
-- CRUD: name/priority/type/scope/team/config/active
-- Dry-run test panel with candidate ranking + health
+**Deferred from v0.22.0–v0.22.2**
+- [ ] _(deferred → v0.23)_ `capability_match` policy type ("cheapest model with tool_calling")
+- [ ] _(deferred → v0.23)_ Latency-aware preference: track response time percentiles, prefer faster providers
+- [ ] _(deferred → v0.23)_ Cost-aware preference with budget ceiling per request
+- [ ] _(deferred → v0.23)_ New provider types registrable via config file (openai-compatible endpoint + custom profile schema)
 
-**New Admin Category: "Routing"**
-- Health, Capabilities, Policies sections
+**Deferred from v0.21.x**
+- [ ] _(deferred → v0.23)_ Mobile: mode selector collapses to hamburger/bottom nav
+- [ ] _(deferred → v0.23)_ Integration with extension loader (surfaces from manifest.json)
+- [ ] _(deferred → v0.23)_ Workspace settings UI: git config section in channel/project settings
+- [ ] _(deferred → v0.23)_ User Settings: git credentials management UI
+- [ ] _(deferred → v0.23)_ `.gitignore` respect in workspace indexing
+- [ ] _(deferred → v0.23)_ Drag-drop file reorder in editor file tree
+- [ ] _(deferred → v0.23)_ Article tools: suggest_outline, expand_section, check_citations (AI-powered)
+- [ ] _(deferred → v0.23)_ Drag-to-reorder outline sections in article mode
+- [x] _(shipped v0.22.4)_ PDF/DOCX export via pandoc in article mode
+- [x] _(shipped v0.22.4)_ Project-specific file uploads (full project-level upload architecture)
 
-**Deferred Tech Debt → Issues**
-- See Rehomed Tech Debt section below
+---
 
-### ✅ v0.22.2 — Routing Policies + Fallback Chains
+## v0.22.4 — Provider Health UX + Project Files + Export ✅
 
-**Routing Policies**
-- `routing_policies` table: type (provider_prefer, team_route, cost_limit, model_alias), config JSONB
-- Evaluated after resolveConfig: requested model → ranked candidates
-- Admin CRUD + test endpoint
+Closes remaining provider infrastructure gaps and delivers UX features
+deferred from earlier releases.
 
-**Fallback Chains**
-- `RunWithFallback()`: try candidates in order, health-aware skip
-- Graceful all-down degradation
+**Provider Infrastructure:**
+- [x] Rate limit tracking per provider config (HTTP 429 classified separately)
+- [x] Tool health tracking (web_search, url_fetch → `tool_health` table)
+- [x] Auto-disable policy (N consecutive "down" windows → deactivate provider)
+- [x] Search provider health tracking via tool health pipeline
+- [x] SQLite health store parity (rate_limit_count, tool health, auto-disable)
+- [x] Config: `PROVIDER_AUTO_DISABLE_THRESHOLD` env var (default: 3)
 
-**Metadata**
-- Headers: `X-Switchboard-Provider`, `X-Switchboard-Route`
-- `routing_decision` in usage_log
+**UX:**
+- [x] Workspace settings UI: git config section in project panel (remote URL, branch, credential)
+- [x] Project-specific file uploads (POST/GET endpoints, project panel UI)
+- [x] PDF/DOCX export via pandoc (POST /api/v1/export, editor menu integration)
+- [x] Admin health dashboard: rate limit count display with warning color
 
-### ✅ v0.22.1 — Provider Extensions (Declarative Config)
+**Frontend:**
+- [x] 5 new API client methods (projectUploadFile, projectListFiles, exportDocument, updateWorkspace, listGitCredentials)
+- [x] Health cards show rate limit counts
+- [x] Git settings section appears when workspace is bound
 
-**Provider Profiles**
-- Schema per provider type (OpenAI, Anthropic, Venice, OpenRouter)
-- `settings` JSONB fully utilized (no hardcoded switches)
+---
 
-**Request/Response Hooks**
-- PreRequest: system prompt prefix, ExtraBody injection
-- PostStreamEvent: normalize provider-specific fields
+## v0.23.0 — Multi-Participant Channels + Presence
 
-**Provider Type Registry**
-- `RegisterType()` with metadata (endpoint, profile schema)
-- `GET /provider-types` endpoint
+The channel foundation for workflows and real-time collaboration. Today
+channels are single-user direct chats. This release makes channels a
+shared space that multiple actors can inhabit.
 
-### ✅ v0.22.0 — Provider Health + Capability Overrides
+Depends on: extension surfaces (v0.21.3), WebSocket infrastructure (already exists).
 
-**Health Tracking**
-- `provider_health` table (hourly buckets)
-- In-memory accumulator, DB flush (60s)
-- Status: healthy/degraded/down based on error rate
+_(Shifted from v0.20.0 — no content changes)_
 
-**Capability Overrides**
-- `capability_overrides` table
-- Resolution: catalog → heuristic → override (highest priority)
+**Channel Participants**
+- [ ] `channel_participants` table: `channel_id`, `participant_type` (user, session, persona), `participant_id`, `role` (owner, member, observer), `joined_at`
+- [ ] Channel access queries rewritten: `WHERE user_id = $1` → participant-based lookup
+- [ ] Backward compatible: existing single-user channels auto-have one participant (owner)
+- [ ] Channel `type` column: `direct` (current), `group` (multi-user), `workflow` (staged)
 
-[... all previous completed sections from v0.9 to v0.21 intact ...]
+**Presence + Real-time**
+- [ ] Typing indicators and presence (who's online, who's in this channel)
+- [ ] Participant join/leave events via WebSocket
+- [ ] Co-editing for extension surfaces (editor mode, article mode)
+- [ ] Cursor sharing, selection highlighting
 
-## Rehomed Tech Debt
+**Channel-Scoped Notes**
+- [ ] Optional `channel_id` FK on notes (NULL = personal notebook, set = channel-attached)
+- [ ] Notes created by tool calls within a channel auto-attach to that channel
+- [ ] Channel notes visible to all participants (not just creator)
 
-All deferred/tech debt from 0.22.* & prior → issues [#98-#143](https://git.gobha.me/xcaliber/chat-switchboard/issues?q=is%3Aopen+%22tech+debt%22).
+---
 
-**Query**: [Open Roadmap Issues](https://git.gobha.me/xcaliber/chat-switchboard/issues?q=is%3Aopen+%22tech+debt%22)
+## v0.24.0 — Auth Strategy (mTLS/OIDC) + Full RBAC
+
+Enterprise auth modes on top of the teams + groups foundation.
+Depends on: vault passphrase support from v0.9.3 (conditional unlock for
+personal providers under external auth), user groups (v0.16.0).
+
+_(Shifted from v0.21.0 — enhanced with group-based permissions)_
+
+- [ ] `AUTH_MODE` env var: `builtin` | `mtls` | `oidc`
+- [ ] All three resolve to the same internal user model
+- [ ] `auth_source` + `external_id` columns on users table
+- [ ] mTLS: header trust, auto-provision from cert DN
+- [ ] OIDC: Keycloak/Okta token validation, claim extraction, role mapping
+- [ ] Per-source auto-activate policy: auto_activate, default_team, default_role
+- [ ] Vault passphrase prompt for mTLS/OIDC users (v0.9.3 conditional unlock)
+- [ ] Fine-grained permissions: model access, KB write, task create, token budgets
+- [ ] Group-based permission sets: assign permissions to groups, users inherit from membership
+- [ ] OIDC claim → group mapping: external IdP groups auto-sync to internal groups
+
+**Anonymous / Session Participants**
+- [ ] Session-based identity for unauthenticated visitors (workflow intake)
+- [ ] mTLS: cert CN/fingerprint as stable session identity (no `users` row required)
+- [ ] Non-mTLS: ephemeral session token (cookie or URL token)
+- [ ] Session participants can send messages and trigger tool calls within workflow channels
+- [ ] Session identity visible to assigned team members (cert DN, display name, or "Anonymous #N")
+
+---
+
+## v0.25.0 — Workflow Engine
+
+Team-owned, stage-based process execution. The channel is the runtime,
+personas drive each stage, and the existing tool/notes infrastructure
+handles structured data collection. See [ARCHITECTURE.md — Workflow
+Architecture](ARCHITECTURE.md#workflow-architecture-future--v0210) for
+the conceptual model.
+
+Depends on: multi-participant channels (v0.23.0), anonymous identity (v0.24.0).
+
+_(Shifted from v0.22.0 — no content changes, dependency refs updated)_
+
+**Workflow Definitions**
+- [ ] `workflows` table: `team_id` (owner), `name`, `description`, `is_active`, `entry_mode` (public_link, team_internal, api)
+- [ ] `workflow_stages` table: `workflow_id`, `ordinal`, `persona_id`, `assignment_team_id`, `form_template` (JSONB, structured note schema), `transition_rules` (JSONB)
+- [ ] Team-admin CRUD: create/edit/delete workflows and stages
+- [ ] Workflow versioning: edits create new version, active instances continue on their version
+
+**Workflow Instances (Channels)**
+- [ ] Workflow-typed channels: `type='workflow'`, `workflow_id`, `current_stage`, `stage_version`
+- [ ] Entry point: public link generates workflow channel, adds anonymous participant, binds stage 1 persona
+- [ ] Stage transitions: triggered by AI (tool call), team member (button), or rule (form complete)
+- [ ] On transition: swap active persona, notify assignment team, update channel metadata
+
+**Go Template Pages (server-rendered entry points)**
+
+Server-rendered HTML via Go `html/template` for pages that need SEO, OG tags,
+pre-auth rendering, or standalone access outside the SPA shell. Same binary,
+same auth middleware, same deployment — no second language runtime.
+
+- [ ] Template engine: Go `html/template` with shared base layout, partials for nav/footer
+- [ ] Route layer: `/w/:slug` for public workflow pages, `/p/:id` for shared project views
+- [ ] Workflow landing page: branded intake form, persona avatar, description — rendered server-side
+- [ ] Shared/embedded surface pages: `/s/editor/:wsId`, `/s/article/:wsId/:path` — server renders minimal shell, JS hydrates surface directly (replaces hash routing for public links)
+- [ ] Template data: workflow metadata, branding, environment banner — injected server-side
+- [ ] Auth gating: public pages skip auth, team pages require session, admin pages require role
+- [ ] Precursor: hash router (v0.21.6) handles in-app navigation; Go templates handle external/public entry points
+
+**AI Intake**
+- [ ] Stage persona drives structured collection via system prompt
+- [ ] Form template → persona system prompt injection ("collect these fields: ...")
+- [ ] Tool calls create channel-scoped notes as form responses
+- [ ] AI determines readiness: "I have everything needed" → trigger transition
+
+**Assignment + Queue**
+- [ ] Assignment queue: unassigned workflow channels visible to team members
+- [ ] Claim model: team member claims channel (becomes participant with `member` role)
+- [ ] Round-robin / rule-based auto-assignment (optional, per-stage config)
+- [ ] Assignment notifications via WebSocket + optional webhook
+
+**Team Member Collaboration**
+- [ ] Assigned member sees full history (AI intake + artifacts + notes)
+- [ ] Persona remains active — assists both visitor and team member
+- [ ] Member can trigger stage transitions, add notes, invoke tools
+- [ ] Member can reassign to different team member or escalate to different team
+
+**Frontend**
+- [ ] Workflow builder UI in team admin panel (stage list, persona picker, form template editor)
+- [ ] Queue view: sidebar section showing unassigned workflow channels for user's teams
+- [ ] Channel header: workflow stage indicator, transition controls
+- [ ] Anonymous visitor view: minimal UI, persona-driven conversation (public link entry)
+
+---
+
+## v0.26.0 — Tasks / Autonomous Agents
+
+Unattended execution — workflows without a human in the loop.
+Depends on: workflow engine (v0.25.0).
+
+_(Shifted from v0.23.0 — no content changes, dependency refs updated)_
+
+- [ ] Scheduler + task runner (cron-like triggers for workflow instantiation)
+- [ ] `task_create` tool (AI can spawn sub-workflows)
+- [ ] `type: 'service'` channels: workflow instances with no human participants
+- [ ] Execution budgets: max tokens, max tool calls, max wall-clock per stage
+- [ ] Admin controls for resource limits and kill switches
+- [ ] Completion webhooks (notify external systems when workflow completes)
+
+---
+
+## TBD (unscheduled — real features, no immediate need)
+
+Items that are real but don't yet have a version assignment. Pull left
+based on need.
+
+**Extension System — Additional Extensions**
+- Image generation tool (browser or sidecar, provider-agnostic)
+- STT/TTS (browser extension, Web Speech API — personal use case)
+- Code execution sandbox (server-side, container isolation)
+
+**Extension System — Server Tiers**
+- Starlark runtime integration (Tier 1 — server sandbox)
+- Sidecar HTTP tool protocol (Tier 2 — container isolation)
+- Server-side tool execution in completion handler
+
+**Desktop + Mobile**
+- Desktop app (Tauri)
+- Full PWA with offline capability
+- Mobile-optimized layouts (beyond current responsive)
+
+**Data + Portability**
+- Bulk export/import (account data, conversations, settings)
+- ChatGPT/other tool import
+- GDPR-style "download my data"
+- Backup/restore CronJob manifests
 
 **UX / Multi-Seat**
-- Per-provider model preferences DB/UI [#99](https://git.gobha.me/xcaliber/chat-switchboard/issues/99)
-- Group scope badges on model/KB selectors [#98](https://git.gobha.me/xcaliber/chat-switchboard/issues/98)
-- Virtual scrolling for long conversations [#101](https://git.gobha.me/xcaliber/chat-switchboard/issues/101)
+- "Group" scope badge on model selector / KB list: show access-source annotation so users see _why_ they have access (global, team, group grant). Requires backend to include `access_source` in list responses.
+- Per-provider model preferences: `user_model_settings` unique key is `(user_id, model_id)` — same model from different providers shares one visibility toggle. Needs `provider_config_id` dimension in DB constraint, store, API, and frontend `hiddenModels` keying. Frontend composite key (`configId:modelId`) already exists in `App.models[].id`.
 
-**Projects**
-- Project-specific files upload/UI [#102](https://git.gobha.me/xcaliber/chat-switchboard/issues/102)
-- Replace project creation prompt() with modal [#100](https://git.gobha.me/xcaliber/chat-switchboard/issues/100)
-- Sub-projects nested hierarchy [#121](https://git.gobha.me/xcaliber/chat-switchboard/issues/121)
-- Admin-level project management [#120](https://git.gobha.me/xcaliber/chat-switchboard/issues/120)
-- Project templates from configs (persona/KB/prompt) [#119](https://git.gobha.me/xcaliber/chat-switchboard/issues/119)
+**Projects — Future**
+- Project-specific files: full project-level upload (own endpoint, storage path, UI surface — not just channel attachment re-linking)
+- Project templates: create new projects from predefined configurations (persona, KBs, system prompt)
+- Project creation dialog: replace `prompt()` with proper modal (name, description, persona, KB picker)
+- Admin-level project management: cross-instance visibility, reassign ownership, enforce team policies (scope: enterprise only, BYOK personal projects stay private)
+- Sub-projects / nested hierarchy: child inherits parent KBs, system prompt, persona (deferred until usage patterns clarify need vs tags/labels)
 
-**Knowledge Bases**
-- Auto-injection top-K chunks to system prompt [#109](https://git.gobha.me/xcaliber/chat-switchboard/issues/109)
-- Hybrid search vector + tsvector + re-rank [#110](https://git.gobha.me/xcaliber/chat-switchboard/issues/110)
-- Semantic chunking via embeddings [#111](https://git.gobha.me/xcaliber/chat-switchboard/issues/111)
-- HNSW index for large datasets [#112](https://git.gobha.me/xcaliber/chat-switchboard/issues/112)
-- Web scraping source ingest [#113](https://git.gobha.me/xcaliber/chat-switchboard/issues/113)
-- Scheduled re-indexing cron [#114](https://git.gobha.me/xcaliber/chat-switchboard/issues/114)
+**Knowledge Bases — Future**
+- KB auto-injection: top-K chunk prepend to system prompt, context budget aware, per-channel toggle (latency budgeting required)
+- Hybrid search: combine vector similarity with full-text `tsvector`, re-rank
+- Semantic chunking: embedding-based boundary detection for smarter splits
+- HNSW index: better query performance than IVFFlat for large datasets
+- Web scraping source: ingest URLs as KB documents (extends url_fetch)
+- Scheduled re-indexing: periodic rebuild when source documents update
+- ~~Store cleanup: add `UpdateDocumentStorageKey()` to `KnowledgeBaseStore` interface~~ _(done in v0.17.0)_
+  (currently uses direct `database.DB.ExecContext` in handler — works but bypasses store layer)
 
-[... all 46 #98-143 links in their sections ...]
+**Memory — Future**
+- Memory compaction: summarize old memories to save context tokens
+- Memory confidence decay: reduce confidence over time, prune low-confidence entries
+- Memory export/import: portable memory format across instances
+- Cross-persona memory sharing (opt-in): e.g. "coding assistant" can read facts from "project manager"
+- Memory analytics: dashboard showing what Personas are learning, memory growth trends
+
+**Platform**
+- Rate limiting per user/team/tier (token budgets)
+- ~~Provider health monitoring~~ → v0.22.0 + key rotation
+- Multi-tenant SaaS mode
+- Plugin/extension marketplace
+- Virtual scroll for long conversations
+- ~~SQLite backend option (single-user / dev)~~ → v0.17.1
 
 **Pane Architecture (Workspace Container)**
 
@@ -147,7 +1238,18 @@ The main area to the right of the sidebar is a **workspace container** that hold
 Each pane is a self-contained unit (chat, editor, notes, preview, etc.) with its own lifecycle.
 Panes compose side-by-side rather than replacing each other (current surface model).
 
-- Implement multi-pane workspace architecture [#142](https://git.gobha.me/xcaliber/chat-switchboard/issues/142)
+- Default layout: Left nav + single Chat pane (what exists today, zero cognitive overhead)
+- Power user: Left nav + Editor pane + Chat pane side by side. Or Editor + Notes. Or all three.
+- Workflow mode: Left nav hidden. Team member gets Chat + History. Customer gets just Chat.
+- User-resizable splits between panes, layout persists per-project or per-user preference
+- The current surface system was a stepping stone — proved out the region/activate/deactivate lifecycle. Panes reuse that contract but drop the "only one active at a time" constraint.
+- Sidebar tabs (Chats / Files) already decouple navigation from center content (v0.21.6)
 
 **Surfaces as Extensions**
-- Surfaces as extensions with marketplace/IDE [#143](https://git.gobha.me/xcaliber/chat-switchboard/issues/143)
\ No newline at end of file
+- Surfaces (future: panes) become first-class extension types alongside block renderers and tool bridges
+- `Surfaces.register()` already defines the contract: name, regions, activate/deactivate callbacks — swap hardcoded JS modules for manifest + dynamically loaded bundles
+- Admin-installable surfaces: upload or enable from extension registry, scoped to team or global
+- Surface manifest in `manifest.json`: declares required regions, capabilities, dependencies
+- Surface IDE: built-in surface for building surfaces — Go template editor for server-rendered shells, JS/CSS editor for client behavior, live preview in sandboxed region. Eats its own dog food.
+- Surface marketplace: share custom surfaces across instances (presentation mode, kanban, form builder, dashboard, etc.)
+- Project-bound surface/pane defaults: project config specifies which panes are available and default layout
\ No newline at end of file
diff --git a/server/config/config.go b/server/config/config.go
index 21c698e..2ad86ee 100644
--- a/server/config/config.go
+++ b/server/config/config.go
@@ -62,6 +62,11 @@ type Config struct {
 	// WORKSPACE_INDEX_CONCURRENCY: max concurrent indexing goroutines (default 2).
 	WorkspaceIndexingEnabled bool
 	WorkspaceIndexConcurrency int
+
+	// Provider auto-disable (v0.22.4)
+	// PROVIDER_AUTO_DISABLE_THRESHOLD: consecutive "down" hourly windows before a
+	// provider is automatically deactivated. Default 3. Set to 0 to disable.
+	ProviderAutoDisableThreshold int
 }
 
 // Load reads configuration from environment variables.
@@ -98,6 +103,8 @@ func Load() *Config {
 
 		WorkspaceIndexingEnabled:  getEnvBool("WORKSPACE_INDEXING_ENABLED", true),
 		WorkspaceIndexConcurrency: getEnvInt("WORKSPACE_INDEX_CONCURRENCY", 2),
+
+		ProviderAutoDisableThreshold: getEnvInt("PROVIDER_AUTO_DISABLE_THRESHOLD", 3),
 	}
 }
 
diff --git a/server/database/migrations/015_v0224_health_enhance.sql b/server/database/migrations/015_v0224_health_enhance.sql
new file mode 100644
index 0000000..676b35e
--- /dev/null
+++ b/server/database/migrations/015_v0224_health_enhance.sql
@@ -0,0 +1,33 @@
+-- v0.22.4: Rate limit tracking, tool health, project files.
+
+-- ── Rate limit column on provider_health ────
+ALTER TABLE provider_health ADD COLUMN IF NOT EXISTS rate_limit_count INT NOT NULL DEFAULT 0;
+
+-- ── Tool Health ─────────────────────────────
+-- Lightweight health tracking for built-in tools (web_search, url_fetch, etc.).
+-- One row per tool per hourly window, similar to provider_health.
+CREATE TABLE IF NOT EXISTS tool_health (
+    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    tool_name       TEXT NOT NULL,                    -- web_search, url_fetch, etc.
+    window_start    TIMESTAMPTZ NOT NULL,             -- hourly bucket floor
+    request_count   INT NOT NULL DEFAULT 0,
+    error_count     INT NOT NULL DEFAULT 0,
+    total_latency_ms BIGINT NOT NULL DEFAULT 0,
+    max_latency_ms  INT NOT NULL DEFAULT 0,
+    last_error      TEXT,
+    last_error_at   TIMESTAMPTZ,
+    updated_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
+
+    UNIQUE (tool_name, window_start)
+);
+
+CREATE INDEX IF NOT EXISTS idx_tool_health_window
+    ON tool_health (tool_name, window_start DESC);
+
+-- ── Project Files ───────────────────────────
+-- Extends attachments to support project-scoped uploads.
+-- When project_id is set, the file belongs to the project (not a message).
+ALTER TABLE attachments ADD COLUMN IF NOT EXISTS project_id UUID REFERENCES projects(id) ON DELETE CASCADE;
+
+CREATE INDEX IF NOT EXISTS idx_attachments_project
+    ON attachments (project_id) WHERE project_id IS NOT NULL;
diff --git a/server/database/migrations/sqlite/014_v0224_health_enhance.sql b/server/database/migrations/sqlite/014_v0224_health_enhance.sql
new file mode 100644
index 0000000..e369f7d
--- /dev/null
+++ b/server/database/migrations/sqlite/014_v0224_health_enhance.sql
@@ -0,0 +1,22 @@
+-- v0.22.4: Rate limit tracking, tool health, project files (SQLite).
+
+-- Rate limit column (SQLite requires full rebuild or default — use default).
+ALTER TABLE provider_health ADD COLUMN rate_limit_count INTEGER NOT NULL DEFAULT 0;
+
+-- Tool Health
+CREATE TABLE IF NOT EXISTS tool_health (
+    id              TEXT PRIMARY KEY,
+    tool_name       TEXT NOT NULL,
+    window_start    TEXT NOT NULL,
+    request_count   INTEGER NOT NULL DEFAULT 0,
+    error_count     INTEGER NOT NULL DEFAULT 0,
+    total_latency_ms INTEGER NOT NULL DEFAULT 0,
+    max_latency_ms  INTEGER NOT NULL DEFAULT 0,
+    last_error      TEXT,
+    last_error_at   TEXT,
+    updated_at      TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE (tool_name, window_start)
+);
+
+-- Project Files
+ALTER TABLE attachments ADD COLUMN project_id TEXT REFERENCES projects(id) ON DELETE CASCADE;
diff --git a/server/handlers/attachments.go b/server/handlers/attachments.go
index 1fbe9b5..25aacd2 100644
--- a/server/handlers/attachments.go
+++ b/server/handlers/attachments.go
@@ -457,6 +457,121 @@ func sanitizeFilename(name string) string {
 	return name
 }
 
+// ── Project Files (v0.22.4) ────────────────
+
+// UploadToProject handles project-scoped file uploads.
+// POST /api/v1/projects/:id/files
+func (h *AttachmentHandler) UploadToProject(c *gin.Context) {
+	if h.objStore == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{"error": "file storage not configured"})
+		return
+	}
+
+	userID := getUserID(c)
+	projectID := c.Param("id")
+
+	// Verify project access (user owns or is team member)
+	var exists bool
+	err := database.DB.QueryRowContext(c.Request.Context(), database.Q(`
+		SELECT EXISTS(
+			SELECT 1 FROM projects
+			WHERE id = $1 AND (owner_id = $2 OR team_id IN (
+				SELECT team_id FROM team_members WHERE user_id = $2 AND is_active = true
+			))
+		)
+	`), projectID, userID).Scan(&exists)
+	if err != nil || !exists {
+		c.JSON(http.StatusForbidden, gin.H{"error": "project not found or access denied"})
+		return
+	}
+
+	file, header, err := c.Request.FormFile("file")
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "no file uploaded"})
+		return
+	}
+	defer file.Close()
+
+	if header.Size > int64(defaultMaxFileSize) {
+		c.JSON(http.StatusRequestEntityTooLarge, gin.H{"error": "file exceeds size limit"})
+		return
+	}
+
+	// Detect content type
+	buf := make([]byte, 512)
+	n, _ := file.Read(buf)
+	contentType := http.DetectContentType(buf[:n])
+	file.Seek(0, io.SeekStart)
+
+	ext := strings.ToLower(filepath.Ext(header.Filename))
+	if better, ok := extToMIME[ext]; ok && contentType == "application/octet-stream" {
+		contentType = better
+	}
+
+	// Store file
+	storageKey := fmt.Sprintf("projects/%s/%s/%s", projectID, store.NewID()[:8], sanitizeFilename(header.Filename))
+	if err := h.objStore.Put(c.Request.Context(), storageKey, file, header.Size, contentType); err != nil {
+		log.Printf("error: project file upload: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to store file"})
+		return
+	}
+
+	att := models.Attachment{
+		ChannelID:   "", // no channel association
+		UserID:      userID,
+		ProjectID:   &projectID,
+		Filename:    header.Filename,
+		ContentType: contentType,
+		SizeBytes:   header.Size,
+		StorageKey:  storageKey,
+	}
+
+	if err := h.stores.Attachments.Create(c.Request.Context(), &att); err != nil {
+		log.Printf("error: project file create: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to save file metadata"})
+		return
+	}
+
+	if h.extQueue != nil {
+		if err := h.extQueue.Enqueue(att.ID, att.StorageKey, contentType, att.Filename); err != nil {
+			log.Printf("warning: project file extraction enqueue failed: %v", err)
+		}
+	}
+
+	c.JSON(http.StatusCreated, att)
+}
+
+// ListByProject returns all files uploaded to a project.
+// GET /api/v1/projects/:id/files
+func (h *AttachmentHandler) ListByProject(c *gin.Context) {
+	userID := getUserID(c)
+	projectID := c.Param("id")
+
+	// Verify project access
+	var exists bool
+	err := database.DB.QueryRowContext(c.Request.Context(), database.Q(`
+		SELECT EXISTS(
+			SELECT 1 FROM projects
+			WHERE id = $1 AND (owner_id = $2 OR team_id IN (
+				SELECT team_id FROM team_members WHERE user_id = $2 AND is_active = true
+			))
+		)
+	`), projectID, userID).Scan(&exists)
+	if err != nil || !exists {
+		c.JSON(http.StatusForbidden, gin.H{"error": "project not found or access denied"})
+		return
+	}
+
+	files, err := h.stores.Attachments.GetByProject(c.Request.Context(), projectID)
+	if err != nil {
+		log.Printf("error: list project files: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list files"})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"files": files, "count": len(files)})
+}
+
 // extToMIME maps file extensions to MIME types for cases where
 // http.DetectContentType returns application/octet-stream.
 var extToMIME = map[string]string{
diff --git a/server/handlers/completion.go b/server/handlers/completion.go
index 65a45bf..a6b1653 100644
--- a/server/handlers/completion.go
+++ b/server/handlers/completion.go
@@ -64,6 +64,9 @@ type HealthRecorder interface {
 	RecordSuccess(providerConfigID string, latencyMs int)
 	RecordError(providerConfigID string, latencyMs int, errMsg string)
 	RecordTimeout(providerConfigID string, latencyMs int, errMsg string)
+	RecordRateLimit(providerConfigID string, latencyMs int, errMsg string) // v0.22.4
+	RecordToolSuccess(toolName string, latencyMs int)                      // v0.22.4
+	RecordToolError(toolName string, latencyMs int, errMsg string)         // v0.22.4
 }
 
 // HealthStatusQuerier retrieves current provider health for routing decisions.
@@ -1365,6 +1368,8 @@ func (h *CompletionHandler) recordHealth(configID string, start time.Time, err e
 		errMsg := err.Error()
 		if strings.Contains(errMsg, "context deadline exceeded") || strings.Contains(errMsg, "timeout") {
 			h.health.RecordTimeout(configID, latencyMs, errMsg)
+		} else if strings.Contains(errMsg, "HTTP 429") || strings.Contains(errMsg, "rate limit") || strings.Contains(errMsg, "Too Many Requests") {
+			h.health.RecordRateLimit(configID, latencyMs, errMsg)
 		} else {
 			h.health.RecordError(configID, latencyMs, errMsg)
 		}
diff --git a/server/handlers/export.go b/server/handlers/export.go
new file mode 100644
index 0000000..662cc51
--- /dev/null
+++ b/server/handlers/export.go
@@ -0,0 +1,110 @@
+package handlers
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+)
+
+// ExportHandler converts markdown content to PDF or DOCX via pandoc.
+type ExportHandler struct{}
+
+func NewExportHandler() *ExportHandler { return &ExportHandler{} }
+
+type exportRequest struct {
+	Content  string `json:"content" binding:"required"`
+	Format   string `json:"format" binding:"required"` // "pdf" or "docx"
+	Filename string `json:"filename"`                  // optional base name
+}
+
+// Convert handles POST /api/v1/export.
+// Converts markdown content to the requested format and returns the file.
+func (h *ExportHandler) Convert(c *gin.Context) {
+	var req exportRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// Validate format
+	switch req.Format {
+	case "pdf", "docx":
+		// ok
+	default:
+		c.JSON(http.StatusBadRequest, gin.H{"error": "format must be pdf or docx"})
+		return
+	}
+
+	// Check pandoc availability
+	if _, err := exec.LookPath("pandoc"); err != nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{"error": "pandoc is not installed on the server"})
+		return
+	}
+
+	// Create temp dir for conversion
+	tmpDir, err := os.MkdirTemp("", "export-*")
+	if err != nil {
+		log.Printf("export: failed to create temp dir: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "export failed"})
+		return
+	}
+	defer os.RemoveAll(tmpDir)
+
+	// Write markdown to temp file
+	inputPath := filepath.Join(tmpDir, "input.md")
+	if err := os.WriteFile(inputPath, []byte(req.Content), 0644); err != nil {
+		log.Printf("export: failed to write input: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "export failed"})
+		return
+	}
+
+	// Determine output filename
+	baseName := "document"
+	if req.Filename != "" {
+		baseName = strings.TrimSuffix(req.Filename, filepath.Ext(req.Filename))
+	}
+	outputFile := baseName + "." + req.Format
+	outputPath := filepath.Join(tmpDir, outputFile)
+
+	// Build pandoc command
+	args := []string{inputPath, "-o", outputPath, "--standalone"}
+	if req.Format == "pdf" {
+		// Try to use a lightweight PDF engine
+		for _, engine := range []string{"weasyprint", "wkhtmltopdf", "pdflatex"} {
+			if _, err := exec.LookPath(engine); err == nil {
+				args = append(args, "--pdf-engine="+engine)
+				break
+			}
+		}
+	}
+
+	cmd := exec.CommandContext(c.Request.Context(), "pandoc", args...)
+	cmd.Dir = tmpDir
+	if output, err := cmd.CombinedOutput(); err != nil {
+		log.Printf("export: pandoc failed: %v\n%s", err, string(output))
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error":   "pandoc conversion failed",
+			"details": string(output),
+		})
+		return
+	}
+
+	// Serve the file
+	contentType := "application/octet-stream"
+	switch req.Format {
+	case "pdf":
+		contentType = "application/pdf"
+	case "docx":
+		contentType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+	}
+
+	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=%q", outputFile))
+	c.File(outputPath)
+	c.Header("Content-Type", contentType)
+}
diff --git a/server/handlers/health_admin.go b/server/handlers/health_admin.go
index c6e3abe..bbf3dbe 100644
--- a/server/handlers/health_admin.go
+++ b/server/handlers/health_admin.go
@@ -79,6 +79,9 @@ func (h *HealthAdminHandler) GetAllProviderHealth(c *gin.Context) {
 			Status:           health.DeriveStatus(w.ErrorRate(), w.RequestCount),
 			RequestCount:     w.RequestCount,
 			ErrorRate:        w.ErrorRate(),
+			ErrorCount:       w.ErrorCount,
+			RateLimitCount:   w.RateLimitCount,
+			TimeoutCount:     w.TimeoutCount,
 			AvgLatencyMs:     w.AvgLatencyMs(),
 			MaxLatencyMs:     w.MaxLatencyMs,
 			LastError:        w.LastError,
diff --git a/server/handlers/stream_loop.go b/server/handlers/stream_loop.go
index 3721bbf..2d6b07b 100644
--- a/server/handlers/stream_loop.go
+++ b/server/handlers/stream_loop.go
@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"log"
 	"net/http"
+	"strings"
 	"time"
 
 	"github.com/gin-gonic/gin"
@@ -35,7 +36,11 @@ func recordHealthFn(hr HealthRecorder, configID string, start time.Time, err err
 	latencyMs := int(time.Since(start).Milliseconds())
 	if err != nil {
 		errMsg := err.Error()
-		hr.RecordError(configID, latencyMs, errMsg)
+		if strings.Contains(errMsg, "HTTP 429") || strings.Contains(errMsg, "rate limit") || strings.Contains(errMsg, "Too Many Requests") {
+			hr.RecordRateLimit(configID, latencyMs, errMsg)
+		} else {
+			hr.RecordError(configID, latencyMs, errMsg)
+		}
 	} else {
 		hr.RecordSuccess(configID, latencyMs)
 	}
@@ -205,9 +210,19 @@ func streamWithToolLoop(
 			var toolResult tools.ToolResult
 
 			// Check if tool is registered locally (server-side)
+			toolStart := time.Now()
 			if tools.Get(call.Name) != nil {
 				log.Printf("🔧 Executing tool (server): %s (call %s)", call.Name, call.ID)
 				toolResult = tools.ExecuteCall(c.Request.Context(), execCtx, call)
+				// Record tool health (v0.22.4)
+				if health != nil {
+					toolLatency := int(time.Since(toolStart).Milliseconds())
+					if toolResult.IsError {
+						health.RecordToolError(call.Name, toolLatency, toolResult.Content)
+					} else {
+						health.RecordToolSuccess(call.Name, toolLatency)
+					}
+				}
 			} else if hub != nil && hub.IsConnected(userID) {
 				// Route to browser via WebSocket bridge
 				log.Printf("🔧 Executing tool (browser): %s (call %s)", call.Name, call.ID)
@@ -418,8 +433,18 @@ func streamModelResponse(
 			}
 
 			var toolResult tools.ToolResult
+			toolStart := time.Now()
 			if tools.Get(call.Name) != nil {
 				toolResult = tools.ExecuteCall(c.Request.Context(), execCtx, call)
+				// Record tool health (v0.22.4)
+				if health != nil {
+					toolLatency := int(time.Since(toolStart).Milliseconds())
+					if toolResult.IsError {
+						health.RecordToolError(call.Name, toolLatency, toolResult.Content)
+					} else {
+						health.RecordToolSuccess(call.Name, toolLatency)
+					}
+				}
 			} else if hub != nil && hub.IsConnected(userID) {
 				toolResult = executeBrowserTool(hub, userID, call)
 			} else {
diff --git a/server/health/accumulator.go b/server/health/accumulator.go
index 614dca4..2adcea4 100644
--- a/server/health/accumulator.go
+++ b/server/health/accumulator.go
@@ -44,6 +44,13 @@ type Store interface {
 
 	// Prune deletes rows older than the given time.
 	Prune(ctx context.Context, before time.Time) (int64, error)
+
+	// ── Tool Health (v0.22.4) ──────────────
+	// UpsertToolWindow merges tool health counters into the hourly bucket.
+	UpsertToolWindow(ctx context.Context, w *models.ToolHealthWindow) error
+
+	// ListAllToolCurrent returns the current-hour bucket for every tool.
+	ListAllToolCurrent(ctx context.Context) ([]models.ToolHealthWindow, error)
 }
 
 // ── In-Memory Bucket ────────────────────────
@@ -54,6 +61,7 @@ type bucket struct {
 	requestCount     int
 	errorCount       int
 	timeoutCount     int
+	rateLimitCount   int
 	totalLatencyMs   int64
 	maxLatencyMs     int
 	lastError        string
@@ -67,23 +75,86 @@ type bucket struct {
 type Accumulator struct {
 	mu      sync.Mutex
 	buckets map[string]*bucket // keyed by provider_config_id
-	store   Store
-	stopCh  chan struct{}
-	wg      sync.WaitGroup
+
+	// Tool health (v0.22.4)
+	toolMu      sync.Mutex
+	toolBuckets map[string]*toolBucket // keyed by tool_name
+
+	store    Store
+	stopCh   chan struct{}
+	wg       sync.WaitGroup
+
+	// Auto-disable (v0.22.4): if set, providers that are "down" for
+	// N consecutive windows get auto-deactivated.
+	autoDisabler         AutoDisabler
+	autoDisableThreshold int // consecutive down windows to trigger (0 = disabled)
+}
+
+// AutoDisabler marks a provider config as inactive. Implemented by the
+// provider store so the accumulator doesn't need to import the store package.
+type AutoDisabler interface {
+	DeactivateProvider(ctx context.Context, configID string) error
+}
+
+// toolBucket holds counters for one tool within one flush interval.
+type toolBucket struct {
+	toolName       string
+	requestCount   int
+	errorCount     int
+	totalLatencyMs int64
+	maxLatencyMs   int
+	lastError      string
+	lastErrorAt    time.Time
 }
 
 // NewAccumulator creates and starts the background flush loop.
 func NewAccumulator(store Store) *Accumulator {
 	a := &Accumulator{
-		buckets: make(map[string]*bucket),
-		store:   store,
-		stopCh:  make(chan struct{}),
+		buckets:     make(map[string]*bucket),
+		toolBuckets: make(map[string]*toolBucket),
+		store:       store,
+		stopCh:      make(chan struct{}),
 	}
 	a.wg.Add(1)
 	go a.flushLoop()
 	return a
 }
 
+// SetAutoDisable configures the auto-disable policy. When a provider
+// has been "down" for N consecutive hourly windows, it is deactivated.
+// N=0 disables the feature.
+func (a *Accumulator) SetAutoDisable(disabler AutoDisabler, threshold int) {
+	a.autoDisabler = disabler
+	a.autoDisableThreshold = threshold
+}
+
+// RecordToolSuccess records a successful tool execution.
+func (a *Accumulator) RecordToolSuccess(toolName string, latencyMs int) {
+	a.toolMu.Lock()
+	defer a.toolMu.Unlock()
+	b := a.getToolBucket(toolName)
+	b.requestCount++
+	b.totalLatencyMs += int64(latencyMs)
+	if latencyMs > b.maxLatencyMs {
+		b.maxLatencyMs = latencyMs
+	}
+}
+
+// RecordToolError records a failed tool execution.
+func (a *Accumulator) RecordToolError(toolName string, latencyMs int, errMsg string) {
+	a.toolMu.Lock()
+	defer a.toolMu.Unlock()
+	b := a.getToolBucket(toolName)
+	b.requestCount++
+	b.errorCount++
+	b.totalLatencyMs += int64(latencyMs)
+	if latencyMs > b.maxLatencyMs {
+		b.maxLatencyMs = latencyMs
+	}
+	b.lastError = errMsg
+	b.lastErrorAt = time.Now().UTC()
+}
+
 // RecordSuccess records a successful provider call.
 func (a *Accumulator) RecordSuccess(providerConfigID string, latencyMs int) {
 	a.mu.Lock()
@@ -127,6 +198,47 @@ func (a *Accumulator) RecordTimeout(providerConfigID string, latencyMs int, errM
 	b.lastErrorAt = time.Now().UTC()
 }
 
+// RecordRateLimit records a rate-limited provider call (HTTP 429).
+// Counted as both an error and a rate limit event.
+func (a *Accumulator) RecordRateLimit(providerConfigID string, latencyMs int, errMsg string) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	b := a.getBucket(providerConfigID)
+	b.requestCount++
+	b.errorCount++
+	b.rateLimitCount++
+	b.totalLatencyMs += int64(latencyMs)
+	if latencyMs > b.maxLatencyMs {
+		b.maxLatencyMs = latencyMs
+	}
+	b.lastError = errMsg
+	b.lastErrorAt = time.Now().UTC()
+}
+
+// IsRateLimitError returns true if the error message indicates an HTTP 429.
+func IsRateLimitError(errMsg string) bool {
+	return len(errMsg) > 0 && (contains(errMsg, "HTTP 429") || contains(errMsg, "rate limit") || contains(errMsg, "too many requests"))
+}
+
+func contains(s, sub string) bool {
+	return len(s) >= len(sub) && (s == sub || len(s) > 0 && containsLower(s, sub))
+}
+
+func containsLower(s, sub string) bool {
+	// Simple case-insensitive contains for short substrings.
+	for i := 0; i <= len(s)-len(sub); i++ {
+		match := true
+		for j := 0; j < len(sub); j++ {
+			sc, tc := s[i+j], sub[j]
+			if sc >= 'A' && sc <= 'Z' { sc += 32 }
+			if tc >= 'A' && tc <= 'Z' { tc += 32 }
+			if sc != tc { match = false; break }
+		}
+		if match { return true }
+	}
+	return false
+}
+
 // Stop halts the flush loop and performs a final flush.
 func (a *Accumulator) Stop() {
 	close(a.stopCh)
@@ -158,6 +270,15 @@ func (a *Accumulator) getBucket(providerConfigID string) *bucket {
 	return b
 }
 
+func (a *Accumulator) getToolBucket(toolName string) *toolBucket {
+	b, ok := a.toolBuckets[toolName]
+	if !ok {
+		b = &toolBucket{toolName: toolName}
+		a.toolBuckets[toolName] = b
+	}
+	return b
+}
+
 func (a *Accumulator) flushLoop() {
 	defer a.wg.Done()
 	ticker := time.NewTicker(FlushInterval)
@@ -167,8 +288,11 @@ func (a *Accumulator) flushLoop() {
 		select {
 		case <-ticker.C:
 			a.flush()
+			a.flushTools()
+			a.checkAutoDisable()
 		case <-a.stopCh:
 			a.flush() // final flush
+			a.flushTools()
 			return
 		}
 	}
@@ -199,6 +323,7 @@ func (a *Accumulator) flush() {
 			RequestCount:     b.requestCount,
 			ErrorCount:       b.errorCount,
 			TimeoutCount:     b.timeoutCount,
+			RateLimitCount:   b.rateLimitCount,
 			TotalLatencyMs:   b.totalLatencyMs,
 			MaxLatencyMs:     b.maxLatencyMs,
 		}
@@ -213,6 +338,89 @@ func (a *Accumulator) flush() {
 	}
 }
 
+// flushTools writes tool health buckets to the database.
+func (a *Accumulator) flushTools() {
+	a.toolMu.Lock()
+	if len(a.toolBuckets) == 0 {
+		a.toolMu.Unlock()
+		return
+	}
+	snap := a.toolBuckets
+	a.toolBuckets = make(map[string]*toolBucket, len(snap))
+	a.toolMu.Unlock()
+
+	windowStart := hourFloor(time.Now().UTC())
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	for _, b := range snap {
+		if b.requestCount == 0 {
+			continue
+		}
+		w := &models.ToolHealthWindow{
+			ToolName:       b.toolName,
+			WindowStart:    windowStart,
+			RequestCount:   b.requestCount,
+			ErrorCount:     b.errorCount,
+			TotalLatencyMs: b.totalLatencyMs,
+			MaxLatencyMs:   b.maxLatencyMs,
+		}
+		if b.lastError != "" {
+			w.LastError = &b.lastError
+			ts := b.lastErrorAt.Format(time.RFC3339)
+			w.LastErrorAt = &ts
+		}
+		if err := a.store.UpsertToolWindow(ctx, w); err != nil {
+			log.Printf("⚠ health: tool flush failed for %s: %v", b.toolName, err)
+		}
+	}
+}
+
+// checkAutoDisable inspects recent health windows and deactivates providers
+// that have been "down" for too many consecutive hours.
+func (a *Accumulator) checkAutoDisable() {
+	if a.autoDisabler == nil || a.autoDisableThreshold <= 0 {
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	// Get current windows for all providers
+	windows, err := a.store.ListAllCurrent(ctx)
+	if err != nil {
+		return
+	}
+
+	for _, w := range windows {
+		status := DeriveStatus(w.ErrorRate(), w.RequestCount)
+		if status != models.StatusDown {
+			continue
+		}
+
+		// Check last N windows — are they all down?
+		recent, err := a.store.ListWindows(ctx, w.ProviderConfigID, a.autoDisableThreshold)
+		if err != nil || len(recent) < a.autoDisableThreshold {
+			continue // not enough data
+		}
+
+		allDown := true
+		for _, rw := range recent {
+			if DeriveStatus(rw.ErrorRate(), rw.RequestCount) != models.StatusDown {
+				allDown = false
+				break
+			}
+		}
+
+		if allDown {
+			log.Printf("⚠ health: auto-disabling provider %s — down for %d consecutive windows", w.ProviderConfigID, a.autoDisableThreshold)
+			if err := a.autoDisabler.DeactivateProvider(ctx, w.ProviderConfigID); err != nil {
+				log.Printf("⚠ health: auto-disable failed for %s: %v", w.ProviderConfigID, err)
+			}
+		}
+	}
+}
+
 // hourFloor truncates a time to the start of its hour.
 func hourFloor(t time.Time) time.Time {
 	return t.Truncate(time.Hour)
diff --git a/server/health/accumulator_test.go b/server/health/accumulator_test.go
index 2a1f078..a837715 100644
--- a/server/health/accumulator_test.go
+++ b/server/health/accumulator_test.go
@@ -70,6 +70,14 @@ func (m *mockStore) ListAllCurrent(_ context.Context) ([]models.ProviderHealthWi
 
 func (m *mockStore) Prune(_ context.Context, _ time.Time) (int64, error) { return 0, nil }
 
+func (m *mockStore) UpsertToolWindow(_ context.Context, _ *models.ToolHealthWindow) error {
+	return nil
+}
+
+func (m *mockStore) ListAllToolCurrent(_ context.Context) ([]models.ToolHealthWindow, error) {
+	return nil, nil
+}
+
 // ── Tests ───────────────────────────────────
 
 func TestRecordSuccess(t *testing.T) {
diff --git a/server/main.go b/server/main.go
index 09a0ccf..b06050f 100644
--- a/server/main.go
+++ b/server/main.go
@@ -29,6 +29,7 @@ import (
 	"git.gobha.me/xcaliber/chat-switchboard/storage"
 	"git.gobha.me/xcaliber/chat-switchboard/store"
 	postgres "git.gobha.me/xcaliber/chat-switchboard/store/postgres"
+	sqliteStore "git.gobha.me/xcaliber/chat-switchboard/store/sqlite"
 	"git.gobha.me/xcaliber/chat-switchboard/tools"
 	"git.gobha.me/xcaliber/chat-switchboard/tools/search"
 	"git.gobha.me/xcaliber/chat-switchboard/workspace"
@@ -57,7 +58,7 @@ func main() {
 	var keyResolver *crypto.KeyResolver
 	var objStore storage.ObjectStore
 	var healthAccum *health.Accumulator
-	var healthStore *postgres.HealthStore
+	var healthStore health.Store
 
 	if err := database.Connect(cfg); err != nil {
 		log.Printf("⚠ Database unavailable: %v", err)
@@ -94,10 +95,28 @@ func main() {
 		stores = postgres.NewStores(database.DB)
 
 		// Provider health accumulator (v0.22.0)
-		healthStore = postgres.NewHealthStore(database.DB)
+		if database.IsSQLite() {
+			healthStore = sqliteStore.NewHealthStore()
+		} else {
+			healthStore = postgres.NewHealthStore(database.DB)
+		}
 		healthAccum = health.NewAccumulator(healthStore)
 		defer healthAccum.Stop()
 
+		// Auto-disable: deactivate providers that are "down" for N consecutive
+		// hourly windows. Configured via PROVIDER_AUTO_DISABLE_THRESHOLD env var.
+		// Default: 3 (3 consecutive "down" hours triggers deactivation). Set to 0 to disable.
+		autoDisableThreshold := 3
+		if v := cfg.ProviderAutoDisableThreshold; v >= 0 {
+			autoDisableThreshold = v
+		}
+		if autoDisableThreshold > 0 {
+			if ad, ok := healthStore.(health.AutoDisabler); ok {
+				healthAccum.SetAutoDisable(ad, autoDisableThreshold)
+				log.Printf("  🛡️ Provider auto-disable: %d consecutive down windows", autoDisableThreshold)
+			}
+		}
+
 		// Background health cleanup: prune windows older than 7 days
 		go func() {
 			ticker := time.NewTicker(6 * time.Hour)
@@ -472,6 +491,15 @@ func main() {
 			protected.DELETE("/projects/:id/notes/:noteId", projectH.RemoveNote)
 			protected.GET("/projects/:id/notes", projectH.ListNotes)
 
+			// Project files (v0.22.4) — wired via attachH which is declared later,
+			// so we use a closure that captures the variable.
+			protected.POST("/projects/:id/files", func(c *gin.Context) {
+				handlers.NewAttachmentHandler(stores, objStore, extQueue).UploadToProject(c)
+			})
+			protected.GET("/projects/:id/files", func(c *gin.Context) {
+				handlers.NewAttachmentHandler(stores, objStore, extQueue).ListByProject(c)
+			})
+
 			// Notifications (v0.20.0)
 			notifH := handlers.NewNotificationHandler(stores, hub)
 			protected.GET("/notifications", notifH.List)
@@ -533,6 +561,10 @@ func main() {
 			protected.GET("/attachments/:id/download", attachH.Download)
 			protected.DELETE("/attachments/:id", attachH.DeleteAttachment)
 
+			// Export (v0.22.4) — pandoc-based markdown → PDF/DOCX conversion
+			exportH := handlers.NewExportHandler()
+			protected.POST("/export", exportH.Convert)
+
 			// Hook: clean up storage files when channels are deleted
 			handlers.SetChannelDeleteHook(attachH.CleanupChannelStorage)
 
diff --git a/server/models/models.go b/server/models/models.go
index ceaf1ff..6a2872a 100644
--- a/server/models/models.go
+++ b/server/models/models.go
@@ -506,6 +506,7 @@ type Attachment struct {
 	ChannelID     string  `json:"channel_id" db:"channel_id"`
 	UserID        string  `json:"user_id" db:"user_id"`
 	MessageID     *string `json:"message_id,omitempty" db:"message_id"`
+	ProjectID     *string `json:"project_id,omitempty" db:"project_id"` // v0.22.4: project-scoped uploads
 	Filename      string  `json:"filename" db:"filename"`
 	ContentType   string  `json:"content_type" db:"content_type"`
 	SizeBytes     int64   `json:"size_bytes" db:"size_bytes"`
@@ -890,6 +891,7 @@ type ProviderHealthWindow struct {
 	RequestCount     int       `json:"request_count" db:"request_count"`
 	ErrorCount       int       `json:"error_count" db:"error_count"`
 	TimeoutCount     int       `json:"timeout_count" db:"timeout_count"`
+	RateLimitCount   int       `json:"rate_limit_count" db:"rate_limit_count"` // v0.22.4
 	TotalLatencyMs   int64     `json:"total_latency_ms" db:"total_latency_ms"`
 	MaxLatencyMs     int       `json:"max_latency_ms" db:"max_latency_ms"`
 	LastError        *string   `json:"last_error,omitempty" db:"last_error"`
@@ -919,12 +921,38 @@ type ProviderHealthSummary struct {
 	Status           ProviderStatus `json:"status"`
 	RequestCount     int            `json:"request_count"`      // last hour
 	ErrorRate        float64        `json:"error_rate"`         // last hour
+	ErrorCount       int            `json:"error_count"`        // last hour
+	RateLimitCount   int            `json:"rate_limit_count"`   // last hour (v0.22.4)
+	TimeoutCount     int            `json:"timeout_count"`      // last hour
 	AvgLatencyMs     int            `json:"avg_latency_ms"`     // last hour
 	MaxLatencyMs     int            `json:"max_latency_ms"`     // last hour
 	LastError        *string        `json:"last_error,omitempty"`
 	LastErrorAt      *string        `json:"last_error_at,omitempty"`
 }
 
+// ToolHealthWindow tracks health of built-in tools (web_search, url_fetch, etc.)
+// in hourly buckets, analogous to ProviderHealthWindow.
+type ToolHealthWindow struct {
+	ID             string    `json:"id" db:"id"`
+	ToolName       string    `json:"tool_name" db:"tool_name"`
+	WindowStart    time.Time `json:"window_start" db:"window_start"`
+	RequestCount   int       `json:"request_count" db:"request_count"`
+	ErrorCount     int       `json:"error_count" db:"error_count"`
+	TotalLatencyMs int64     `json:"total_latency_ms" db:"total_latency_ms"`
+	MaxLatencyMs   int       `json:"max_latency_ms" db:"max_latency_ms"`
+	LastError      *string   `json:"last_error,omitempty" db:"last_error"`
+	LastErrorAt    *string   `json:"last_error_at,omitempty" db:"last_error_at"`
+}
+
+// ToolHealthSummary is the API response for a tool's health.
+type ToolHealthSummary struct {
+	ToolName     string  `json:"tool_name"`
+	Status       string  `json:"status"` // healthy, degraded, down, unknown
+	RequestCount int     `json:"request_count"`
+	ErrorRate    float64 `json:"error_rate"`
+	AvgLatencyMs int     `json:"avg_latency_ms"`
+}
+
 // =========================================
 // CAPABILITY OVERRIDES (v0.22.0)
 // =========================================
diff --git a/server/store/interfaces.go b/server/store/interfaces.go
index 264b0a1..4928c1a 100644
--- a/server/store/interfaces.go
+++ b/server/store/interfaces.go
@@ -393,6 +393,7 @@ type AttachmentStore interface {
 	GetByID(ctx context.Context, id string) (*models.Attachment, error)
 	GetByChannel(ctx context.Context, channelID string) ([]models.Attachment, error)
 	GetByMessage(ctx context.Context, messageID string) ([]models.Attachment, error)
+	GetByProject(ctx context.Context, projectID string) ([]models.Attachment, error) // v0.22.4
 	SetMessageID(ctx context.Context, attachmentID, messageID string) error
 	UpdateMetadata(ctx context.Context, id string, metadata map[string]interface{}) error
 	SetExtractedText(ctx context.Context, id string, text string) error
diff --git a/server/store/postgres/attachment.go b/server/store/postgres/attachment.go
index 7d1c210..5fe86f8 100644
--- a/server/store/postgres/attachment.go
+++ b/server/store/postgres/attachment.go
@@ -14,18 +14,19 @@ type AttachmentStore struct{}
 func NewAttachmentStore() *AttachmentStore { return &AttachmentStore{} }
 
 // ── columns shared across queries ──────────
-const attachmentCols = `id, channel_id, user_id, message_id, filename, content_type,
+const attachmentCols = `id, channel_id, user_id, message_id, project_id, filename, content_type,
 	size_bytes, storage_key, extracted_text, metadata, created_at`
 
 // scanAttachment scans a row into an Attachment struct.
 func scanAttachment(row interface{ Scan(dest ...interface{}) error }) (*models.Attachment, error) {
 	var a models.Attachment
 	var messageID sql.NullString
+	var projectID sql.NullString
 	var extractedText sql.NullString
 	var metadataJSON []byte
 
 	err := row.Scan(
-		&a.ID, &a.ChannelID, &a.UserID, &messageID,
+		&a.ID, &a.ChannelID, &a.UserID, &messageID, &projectID,
 		&a.Filename, &a.ContentType, &a.SizeBytes,
 		&a.StorageKey, &extractedText, &metadataJSON, &a.CreatedAt,
 	)
@@ -34,6 +35,7 @@ func scanAttachment(row interface{ Scan(dest ...interface{}) error }) (*models.A
 	}
 
 	a.MessageID = NullableStringPtr(messageID)
+	a.ProjectID = NullableStringPtr(projectID)
 	if extractedText.Valid {
 		a.ExtractedText = &extractedText.String
 	}
@@ -45,11 +47,12 @@ func scanAttachment(row interface{ Scan(dest ...interface{}) error }) (*models.A
 
 func (s *AttachmentStore) Create(ctx context.Context, a *models.Attachment) error {
 	return DB.QueryRowContext(ctx, `
-		INSERT INTO attachments (channel_id, user_id, message_id, filename, content_type,
+		INSERT INTO attachments (channel_id, user_id, message_id, project_id, filename, content_type,
 			size_bytes, storage_key, extracted_text, metadata)
-		VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)
+		VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10)
 		RETURNING id, created_at`,
 		a.ChannelID, a.UserID, models.NullString(a.MessageID),
+		models.NullString(a.ProjectID),
 		a.Filename, a.ContentType, a.SizeBytes,
 		a.StorageKey, models.NullString(a.ExtractedText),
 		ToJSON(a.Metadata),
@@ -99,6 +102,26 @@ func (s *AttachmentStore) GetByMessage(ctx context.Context, messageID string) ([
 	return out, rows.Err()
 }
 
+// GetByProject returns all attachments for a project (v0.22.4).
+func (s *AttachmentStore) GetByProject(ctx context.Context, projectID string) ([]models.Attachment, error) {
+	rows, err := DB.QueryContext(ctx,
+		`SELECT `+attachmentCols+` FROM attachments WHERE project_id = $1 ORDER BY created_at`, projectID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var out []models.Attachment
+	for rows.Next() {
+		a, err := scanAttachment(rows)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, *a)
+	}
+	return out, rows.Err()
+}
+
 func (s *AttachmentStore) SetMessageID(ctx context.Context, attachmentID, messageID string) error {
 	_, err := DB.ExecContext(ctx,
 		`UPDATE attachments SET message_id = $1 WHERE id = $2`,
diff --git a/server/store/postgres/health.go b/server/store/postgres/health.go
index ba6a5df..55eb173 100644
--- a/server/store/postgres/health.go
+++ b/server/store/postgres/health.go
@@ -20,20 +20,21 @@ func NewHealthStore(db *sql.DB) *HealthStore {
 func (s *HealthStore) UpsertWindow(ctx context.Context, w *models.ProviderHealthWindow) error {
 	_, err := s.db.ExecContext(ctx, `
 		INSERT INTO provider_health (provider_config_id, window_start,
-			request_count, error_count, timeout_count,
+			request_count, error_count, timeout_count, rate_limit_count,
 			total_latency_ms, max_latency_ms, last_error, last_error_at, updated_at)
-		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, now())
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, now())
 		ON CONFLICT (provider_config_id, window_start) DO UPDATE SET
-			request_count   = provider_health.request_count + EXCLUDED.request_count,
-			error_count     = provider_health.error_count + EXCLUDED.error_count,
-			timeout_count   = provider_health.timeout_count + EXCLUDED.timeout_count,
+			request_count    = provider_health.request_count + EXCLUDED.request_count,
+			error_count      = provider_health.error_count + EXCLUDED.error_count,
+			timeout_count    = provider_health.timeout_count + EXCLUDED.timeout_count,
+			rate_limit_count = provider_health.rate_limit_count + EXCLUDED.rate_limit_count,
 			total_latency_ms = provider_health.total_latency_ms + EXCLUDED.total_latency_ms,
-			max_latency_ms  = GREATEST(provider_health.max_latency_ms, EXCLUDED.max_latency_ms),
-			last_error      = COALESCE(EXCLUDED.last_error, provider_health.last_error),
-			last_error_at   = COALESCE(EXCLUDED.last_error_at, provider_health.last_error_at),
-			updated_at      = now()
+			max_latency_ms   = GREATEST(provider_health.max_latency_ms, EXCLUDED.max_latency_ms),
+			last_error       = COALESCE(EXCLUDED.last_error, provider_health.last_error),
+			last_error_at    = COALESCE(EXCLUDED.last_error_at, provider_health.last_error_at),
+			updated_at       = now()
 	`, w.ProviderConfigID, w.WindowStart,
-		w.RequestCount, w.ErrorCount, w.TimeoutCount,
+		w.RequestCount, w.ErrorCount, w.TimeoutCount, w.RateLimitCount,
 		w.TotalLatencyMs, w.MaxLatencyMs, w.LastError, w.LastErrorAt,
 	)
 	return err
@@ -44,13 +45,13 @@ func (s *HealthStore) GetCurrentWindow(ctx context.Context, providerConfigID str
 	var w models.ProviderHealthWindow
 	err := s.db.QueryRowContext(ctx, `
 		SELECT id, provider_config_id, window_start,
-			request_count, error_count, timeout_count,
+			request_count, error_count, timeout_count, rate_limit_count,
 			total_latency_ms, max_latency_ms, last_error, last_error_at
 		FROM provider_health
 		WHERE provider_config_id = $1 AND window_start = $2
 	`, providerConfigID, windowStart).Scan(
 		&w.ID, &w.ProviderConfigID, &w.WindowStart,
-		&w.RequestCount, &w.ErrorCount, &w.TimeoutCount,
+		&w.RequestCount, &w.ErrorCount, &w.TimeoutCount, &w.RateLimitCount,
 		&w.TotalLatencyMs, &w.MaxLatencyMs, &w.LastError, &w.LastErrorAt,
 	)
 	if err == sql.ErrNoRows {
@@ -62,7 +63,7 @@ func (s *HealthStore) GetCurrentWindow(ctx context.Context, providerConfigID str
 func (s *HealthStore) ListWindows(ctx context.Context, providerConfigID string, hours int) ([]models.ProviderHealthWindow, error) {
 	rows, err := s.db.QueryContext(ctx, `
 		SELECT id, provider_config_id, window_start,
-			request_count, error_count, timeout_count,
+			request_count, error_count, timeout_count, rate_limit_count,
 			total_latency_ms, max_latency_ms, last_error, last_error_at
 		FROM provider_health
 		WHERE provider_config_id = $1
@@ -79,7 +80,7 @@ func (s *HealthStore) ListWindows(ctx context.Context, providerConfigID string,
 		var w models.ProviderHealthWindow
 		if err := rows.Scan(
 			&w.ID, &w.ProviderConfigID, &w.WindowStart,
-			&w.RequestCount, &w.ErrorCount, &w.TimeoutCount,
+			&w.RequestCount, &w.ErrorCount, &w.TimeoutCount, &w.RateLimitCount,
 			&w.TotalLatencyMs, &w.MaxLatencyMs, &w.LastError, &w.LastErrorAt,
 		); err != nil {
 			return nil, err
@@ -93,7 +94,7 @@ func (s *HealthStore) ListAllCurrent(ctx context.Context) ([]models.ProviderHeal
 	windowStart := time.Now().UTC().Truncate(time.Hour)
 	rows, err := s.db.QueryContext(ctx, `
 		SELECT id, provider_config_id, window_start,
-			request_count, error_count, timeout_count,
+			request_count, error_count, timeout_count, rate_limit_count,
 			total_latency_ms, max_latency_ms, last_error, last_error_at
 		FROM provider_health
 		WHERE window_start = $1
@@ -109,7 +110,7 @@ func (s *HealthStore) ListAllCurrent(ctx context.Context) ([]models.ProviderHeal
 		var w models.ProviderHealthWindow
 		if err := rows.Scan(
 			&w.ID, &w.ProviderConfigID, &w.WindowStart,
-			&w.RequestCount, &w.ErrorCount, &w.TimeoutCount,
+			&w.RequestCount, &w.ErrorCount, &w.TimeoutCount, &w.RateLimitCount,
 			&w.TotalLatencyMs, &w.MaxLatencyMs, &w.LastError, &w.LastErrorAt,
 		); err != nil {
 			return nil, err
@@ -126,5 +127,66 @@ func (s *HealthStore) Prune(ctx context.Context, before time.Time) (int64, error
 	if err != nil {
 		return 0, err
 	}
+	// Also prune tool health
+	s.db.ExecContext(ctx, `DELETE FROM tool_health WHERE window_start < $1`, before)
 	return result.RowsAffected()
 }
+
+// ── Tool Health (v0.22.4) ────────────────────
+
+func (s *HealthStore) UpsertToolWindow(ctx context.Context, w *models.ToolHealthWindow) error {
+	_, err := s.db.ExecContext(ctx, `
+		INSERT INTO tool_health (tool_name, window_start,
+			request_count, error_count, total_latency_ms, max_latency_ms,
+			last_error, last_error_at, updated_at)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, now())
+		ON CONFLICT (tool_name, window_start) DO UPDATE SET
+			request_count    = tool_health.request_count + EXCLUDED.request_count,
+			error_count      = tool_health.error_count + EXCLUDED.error_count,
+			total_latency_ms = tool_health.total_latency_ms + EXCLUDED.total_latency_ms,
+			max_latency_ms   = GREATEST(tool_health.max_latency_ms, EXCLUDED.max_latency_ms),
+			last_error       = COALESCE(EXCLUDED.last_error, tool_health.last_error),
+			last_error_at    = COALESCE(EXCLUDED.last_error_at, tool_health.last_error_at),
+			updated_at       = now()
+	`, w.ToolName, w.WindowStart,
+		w.RequestCount, w.ErrorCount, w.TotalLatencyMs, w.MaxLatencyMs,
+		w.LastError, w.LastErrorAt,
+	)
+	return err
+}
+
+func (s *HealthStore) ListAllToolCurrent(ctx context.Context) ([]models.ToolHealthWindow, error) {
+	windowStart := time.Now().UTC().Truncate(time.Hour)
+	rows, err := s.db.QueryContext(ctx, `
+		SELECT id, tool_name, window_start,
+			request_count, error_count, total_latency_ms, max_latency_ms,
+			last_error, last_error_at
+		FROM tool_health
+		WHERE window_start = $1
+		ORDER BY tool_name
+	`, windowStart)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var result []models.ToolHealthWindow
+	for rows.Next() {
+		var w models.ToolHealthWindow
+		if err := rows.Scan(
+			&w.ID, &w.ToolName, &w.WindowStart,
+			&w.RequestCount, &w.ErrorCount, &w.TotalLatencyMs, &w.MaxLatencyMs,
+			&w.LastError, &w.LastErrorAt,
+		); err != nil {
+			return nil, err
+		}
+		result = append(result, w)
+	}
+	return result, rows.Err()
+}
+
+// DeactivateProvider marks a provider config as inactive (for auto-disable).
+func (s *HealthStore) DeactivateProvider(ctx context.Context, configID string) error {
+	_, err := s.db.ExecContext(ctx, `UPDATE provider_configs SET is_active = false WHERE id = $1`, configID)
+	return err
+}
diff --git a/server/store/sqlite/attachment.go b/server/store/sqlite/attachment.go
index b629ac7..17bd241 100644
--- a/server/store/sqlite/attachment.go
+++ b/server/store/sqlite/attachment.go
@@ -15,18 +15,19 @@ type AttachmentStore struct{}
 func NewAttachmentStore() *AttachmentStore { return &AttachmentStore{} }
 
 // ── columns shared across queries ──────────
-const attachmentCols = `id, channel_id, user_id, message_id, filename, content_type,
+const attachmentCols = `id, channel_id, user_id, message_id, project_id, filename, content_type,
 	size_bytes, storage_key, extracted_text, metadata, created_at`
 
 // scanAttachment scans a row into an Attachment struct.
 func scanAttachment(row interface{ Scan(dest ...interface{}) error }) (*models.Attachment, error) {
 	var a models.Attachment
 	var messageID sql.NullString
+	var projectID sql.NullString
 	var extractedText sql.NullString
 	var metadataJSON []byte
 
 	err := row.Scan(
-		&a.ID, &a.ChannelID, &a.UserID, &messageID,
+		&a.ID, &a.ChannelID, &a.UserID, &messageID, &projectID,
 		&a.Filename, &a.ContentType, &a.SizeBytes,
 		&a.StorageKey, &extractedText, &metadataJSON, st(&a.CreatedAt),
 	)
@@ -35,6 +36,7 @@ func scanAttachment(row interface{ Scan(dest ...interface{}) error }) (*models.A
 	}
 
 	a.MessageID = NullableStringPtr(messageID)
+	a.ProjectID = NullableStringPtr(projectID)
 	if extractedText.Valid {
 		a.ExtractedText = &extractedText.String
 	}
@@ -48,10 +50,11 @@ func (s *AttachmentStore) Create(ctx context.Context, a *models.Attachment) erro
 	a.ID = store.NewID()
 	a.CreatedAt = time.Now().UTC()
 	_, err := DB.ExecContext(ctx, `
-		INSERT INTO attachments (id, channel_id, user_id, message_id, filename, content_type,
+		INSERT INTO attachments (id, channel_id, user_id, message_id, project_id, filename, content_type,
 			size_bytes, storage_key, extracted_text, metadata, created_at)
-		VALUES (?,?,?,?,?,?,?,?,?,?,?)`,
+		VALUES (?,?,?,?,?,?,?,?,?,?,?,?)`,
 		a.ID, a.ChannelID, a.UserID, models.NullString(a.MessageID),
+		models.NullString(a.ProjectID),
 		a.Filename, a.ContentType, a.SizeBytes,
 		a.StorageKey, models.NullString(a.ExtractedText),
 		ToJSON(a.Metadata), a.CreatedAt.Format(timeFmt),
@@ -102,6 +105,26 @@ func (s *AttachmentStore) GetByMessage(ctx context.Context, messageID string) ([
 	return out, rows.Err()
 }
 
+// GetByProject returns all attachments for a project (v0.22.4).
+func (s *AttachmentStore) GetByProject(ctx context.Context, projectID string) ([]models.Attachment, error) {
+	rows, err := DB.QueryContext(ctx,
+		`SELECT `+attachmentCols+` FROM attachments WHERE project_id = ? ORDER BY created_at`, projectID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var out []models.Attachment
+	for rows.Next() {
+		a, err := scanAttachment(rows)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, *a)
+	}
+	return out, rows.Err()
+}
+
 func (s *AttachmentStore) SetMessageID(ctx context.Context, attachmentID, messageID string) error {
 	_, err := DB.ExecContext(ctx,
 		`UPDATE attachments SET message_id = ? WHERE id = ?`,
diff --git a/server/store/sqlite/health.go b/server/store/sqlite/health.go
index 7c11b10..e160f6f 100644
--- a/server/store/sqlite/health.go
+++ b/server/store/sqlite/health.go
@@ -18,20 +18,21 @@ func (s *HealthStore) UpsertWindow(ctx context.Context, w *models.ProviderHealth
 	windowStr := w.WindowStart.Format(timeFmt)
 	_, err := DB.ExecContext(ctx, `
 		INSERT INTO provider_health (id, provider_config_id, window_start,
-			request_count, error_count, timeout_count,
+			request_count, error_count, timeout_count, rate_limit_count,
 			total_latency_ms, max_latency_ms, last_error, last_error_at, updated_at)
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
 		ON CONFLICT (provider_config_id, window_start) DO UPDATE SET
-			request_count   = provider_health.request_count + excluded.request_count,
-			error_count     = provider_health.error_count + excluded.error_count,
-			timeout_count   = provider_health.timeout_count + excluded.timeout_count,
+			request_count    = provider_health.request_count + excluded.request_count,
+			error_count      = provider_health.error_count + excluded.error_count,
+			timeout_count    = provider_health.timeout_count + excluded.timeout_count,
+			rate_limit_count = provider_health.rate_limit_count + excluded.rate_limit_count,
 			total_latency_ms = provider_health.total_latency_ms + excluded.total_latency_ms,
-			max_latency_ms  = MAX(provider_health.max_latency_ms, excluded.max_latency_ms),
-			last_error      = COALESCE(excluded.last_error, provider_health.last_error),
-			last_error_at   = COALESCE(excluded.last_error_at, provider_health.last_error_at),
-			updated_at      = datetime('now')
+			max_latency_ms   = MAX(provider_health.max_latency_ms, excluded.max_latency_ms),
+			last_error       = COALESCE(excluded.last_error, provider_health.last_error),
+			last_error_at    = COALESCE(excluded.last_error_at, provider_health.last_error_at),
+			updated_at       = datetime('now')
 	`, id, w.ProviderConfigID, windowStr,
-		w.RequestCount, w.ErrorCount, w.TimeoutCount,
+		w.RequestCount, w.ErrorCount, w.TimeoutCount, w.RateLimitCount,
 		w.TotalLatencyMs, w.MaxLatencyMs, w.LastError, w.LastErrorAt,
 	)
 	return err
@@ -43,13 +44,13 @@ func (s *HealthStore) GetCurrentWindow(ctx context.Context, providerConfigID str
 	var windowStartStr string
 	err := DB.QueryRowContext(ctx, `
 		SELECT id, provider_config_id, window_start,
-			request_count, error_count, timeout_count,
+			request_count, error_count, timeout_count, rate_limit_count,
 			total_latency_ms, max_latency_ms, last_error, last_error_at
 		FROM provider_health
 		WHERE provider_config_id = ? AND window_start = ?
 	`, providerConfigID, windowStr).Scan(
 		&w.ID, &w.ProviderConfigID, &windowStartStr,
-		&w.RequestCount, &w.ErrorCount, &w.TimeoutCount,
+		&w.RequestCount, &w.ErrorCount, &w.TimeoutCount, &w.RateLimitCount,
 		&w.TotalLatencyMs, &w.MaxLatencyMs, &w.LastError, &w.LastErrorAt,
 	)
 	if err == sql.ErrNoRows {
@@ -65,7 +66,7 @@ func (s *HealthStore) GetCurrentWindow(ctx context.Context, providerConfigID str
 func (s *HealthStore) ListWindows(ctx context.Context, providerConfigID string, hours int) ([]models.ProviderHealthWindow, error) {
 	rows, err := DB.QueryContext(ctx, `
 		SELECT id, provider_config_id, window_start,
-			request_count, error_count, timeout_count,
+			request_count, error_count, timeout_count, rate_limit_count,
 			total_latency_ms, max_latency_ms, last_error, last_error_at
 		FROM provider_health
 		WHERE provider_config_id = ?
@@ -83,7 +84,7 @@ func (s *HealthStore) ListAllCurrent(ctx context.Context) ([]models.ProviderHeal
 	windowStr := time.Now().UTC().Truncate(time.Hour).Format(timeFmt)
 	rows, err := DB.QueryContext(ctx, `
 		SELECT id, provider_config_id, window_start,
-			request_count, error_count, timeout_count,
+			request_count, error_count, timeout_count, rate_limit_count,
 			total_latency_ms, max_latency_ms, last_error, last_error_at
 		FROM provider_health
 		WHERE window_start = ?
@@ -103,9 +104,72 @@ func (s *HealthStore) Prune(ctx context.Context, before time.Time) (int64, error
 	if err != nil {
 		return 0, err
 	}
+	DB.ExecContext(ctx, `DELETE FROM tool_health WHERE window_start < ?`, before.Format(timeFmt))
 	return result.RowsAffected()
 }
 
+// ── Tool Health (v0.22.4) ────────────────────
+
+func (s *HealthStore) UpsertToolWindow(ctx context.Context, w *models.ToolHealthWindow) error {
+	id := store.NewID()
+	windowStr := w.WindowStart.Format(timeFmt)
+	_, err := DB.ExecContext(ctx, `
+		INSERT INTO tool_health (id, tool_name, window_start,
+			request_count, error_count, total_latency_ms, max_latency_ms,
+			last_error, last_error_at, updated_at)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+		ON CONFLICT (tool_name, window_start) DO UPDATE SET
+			request_count    = tool_health.request_count + excluded.request_count,
+			error_count      = tool_health.error_count + excluded.error_count,
+			total_latency_ms = tool_health.total_latency_ms + excluded.total_latency_ms,
+			max_latency_ms   = MAX(tool_health.max_latency_ms, excluded.max_latency_ms),
+			last_error       = COALESCE(excluded.last_error, tool_health.last_error),
+			last_error_at    = COALESCE(excluded.last_error_at, tool_health.last_error_at),
+			updated_at       = datetime('now')
+	`, id, w.ToolName, windowStr,
+		w.RequestCount, w.ErrorCount, w.TotalLatencyMs, w.MaxLatencyMs,
+		w.LastError, w.LastErrorAt,
+	)
+	return err
+}
+
+func (s *HealthStore) ListAllToolCurrent(ctx context.Context) ([]models.ToolHealthWindow, error) {
+	windowStr := time.Now().UTC().Truncate(time.Hour).Format(timeFmt)
+	rows, err := DB.QueryContext(ctx, `
+		SELECT id, tool_name, window_start,
+			request_count, error_count, total_latency_ms, max_latency_ms,
+			last_error, last_error_at
+		FROM tool_health
+		WHERE window_start = ?
+		ORDER BY tool_name
+	`, windowStr)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var result []models.ToolHealthWindow
+	for rows.Next() {
+		var w models.ToolHealthWindow
+		var windowStartStr string
+		if err := rows.Scan(
+			&w.ID, &w.ToolName, &windowStartStr,
+			&w.RequestCount, &w.ErrorCount, &w.TotalLatencyMs, &w.MaxLatencyMs,
+			&w.LastError, &w.LastErrorAt,
+		); err != nil {
+			return nil, err
+		}
+		w.WindowStart, _ = time.Parse(timeFmt, windowStartStr)
+		result = append(result, w)
+	}
+	return result, rows.Err()
+}
+
+func (s *HealthStore) DeactivateProvider(ctx context.Context, configID string) error {
+	_, err := DB.ExecContext(ctx, `UPDATE provider_configs SET is_active = 0 WHERE id = ?`, configID)
+	return err
+}
+
 func scanHealthRows(rows *sql.Rows) ([]models.ProviderHealthWindow, error) {
 	var result []models.ProviderHealthWindow
 	for rows.Next() {
@@ -113,7 +177,7 @@ func scanHealthRows(rows *sql.Rows) ([]models.ProviderHealthWindow, error) {
 		var windowStartStr string
 		if err := rows.Scan(
 			&w.ID, &w.ProviderConfigID, &windowStartStr,
-			&w.RequestCount, &w.ErrorCount, &w.TimeoutCount,
+			&w.RequestCount, &w.ErrorCount, &w.TimeoutCount, &w.RateLimitCount,
 			&w.TotalLatencyMs, &w.MaxLatencyMs, &w.LastError, &w.LastErrorAt,
 		); err != nil {
 			return nil, err
diff --git a/src/js/api.js b/src/js/api.js
index 81b7062..88b6664 100644
--- a/src/js/api.js
+++ b/src/js/api.js
@@ -259,6 +259,8 @@ const API = {
     getWorkspaceGitBranches(wsId) { return this._get(`/api/v1/workspaces/${wsId}/git/branches`); },
     listWorkspaces() { return this._get('/api/v1/workspaces'); },
     createWorkspace(data) { return this._post('/api/v1/workspaces', data); },
+    updateWorkspace(id, patch) { return this._patch(`/api/v1/workspaces/${id}`, patch); },
+    listGitCredentials() { return this._get('/api/v1/git-credentials'); },
 
     // ── Messages ─────────────────────────────
 
@@ -727,6 +729,33 @@ const API = {
     adminListCapabilityOverrides() { return this._get('/api/v1/admin/capability-overrides'); },
     adminGetProviderTypes() { return this._get('/api/v1/admin/provider-types'); },
 
+    // ── Project Files (v0.22.4) ─────────────
+    async projectUploadFile(projectId, file) {
+        const form = new FormData();
+        form.append('file', file, file.name);
+        const doFetch = () => fetch(BASE + `/api/v1/projects/${projectId}/files`, {
+            method: 'POST',
+            headers: { 'Authorization': `Bearer ${this.accessToken}` },
+            body: form,
+        });
+        let resp = await doFetch();
+        if (resp.status === 401 && this.refreshToken) {
+            await this._refreshAccessToken();
+            resp = await doFetch();
+        }
+        if (!resp.ok) {
+            const data = await resp.json().catch(() => ({}));
+            throw new Error(data.error || `HTTP ${resp.status}`);
+        }
+        return resp.json();
+    },
+    projectListFiles(projectId) { return this._get(`/api/v1/projects/${projectId}/files`); },
+
+    // ── Export (v0.22.4) ────────────────────
+    exportDocument(content, format, filename) {
+        return this._post('/api/v1/export', { content, format, filename });
+    },
+
     // ── User Usage ──────────────────────────
     getMyUsage(params) {
         const q = new URLSearchParams();
diff --git a/src/js/editor-mode.js b/src/js/editor-mode.js
index 08d5131..6680acc 100644
--- a/src/js/editor-mode.js
+++ b/src/js/editor-mode.js
@@ -333,6 +333,8 @@ const EditorMode = {
                     <div class="editor-export-menu" id="editorExportMenu">
                         <button class="editor-export-item" data-format="md">Download file</button>
                         <button class="editor-export-item" data-format="html">Export as HTML</button>
+                        <button class="editor-export-item" data-format="pdf">Export as PDF</button>
+                        <button class="editor-export-item" data-format="docx">Export as DOCX</button>
                         <button class="editor-export-item" data-format="clipboard">Copy to clipboard</button>
                     </div>
                 </div>
@@ -1020,6 +1022,37 @@ pre{background:#f5f5f5;padding:16px;border-radius:6px;overflow-x:auto}code{font-
                 a.click(); URL.revokeObjectURL(url);
                 break;
             }
+            case 'pdf':
+            case 'docx': {
+                try {
+                    if (typeof UI !== 'undefined') UI.toast(`Exporting as ${format.toUpperCase()}…`, 'info');
+                    const resp = await fetch(
+                        (window.BASE_PATH || '') + '/api/v1/export',
+                        {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json',
+                                'Authorization': `Bearer ${API.accessToken}`,
+                            },
+                            body: JSON.stringify({ content, format, filename: fileName }),
+                        }
+                    );
+                    if (!resp.ok) {
+                        const data = await resp.json().catch(() => ({}));
+                        throw new Error(data.error || `HTTP ${resp.status}`);
+                    }
+                    const blob = await resp.blob();
+                    const url = URL.createObjectURL(blob);
+                    const a = document.createElement('a');
+                    a.href = url;
+                    a.download = fileName.replace(/\.[^.]+$/, '.' + format);
+                    a.click();
+                    URL.revokeObjectURL(url);
+                } catch (e) {
+                    if (typeof UI !== 'undefined') UI.toast(`Export failed: ${e.message}`, 'error');
+                }
+                break;
+            }
             case 'clipboard': {
                 try {
                     await navigator.clipboard.writeText(content);
diff --git a/src/js/projects-ui.js b/src/js/projects-ui.js
index fe3dd2b..29d8840 100644
--- a/src/js/projects-ui.js
+++ b/src/js/projects-ui.js
@@ -409,6 +409,26 @@ function _registerProjectPanel() {
                 </div>
                 <div class="project-panel-hint">Workspace files are available to AI in all project chats. Enables the Editor surface.</div>
             </div>
+            <div class="project-panel-section" id="projectGitSection" style="display:none">
+                <label class="project-panel-label">Git Settings</label>
+                <div style="display:flex;flex-direction:column;gap:6px">
+                    <input type="text" id="projectGitRemote" class="project-panel-input" placeholder="Git remote URL (https://...)" spellcheck="false">
+                    <input type="text" id="projectGitBranch" class="project-panel-input" placeholder="Branch (default: main)" spellcheck="false">
+                    <select id="projectGitCredential" class="project-panel-select">
+                        <option value="">No credential</option>
+                    </select>
+                    <button class="btn-small" id="projectGitSave">Save Git Config</button>
+                </div>
+                <div class="project-panel-hint">Configure git remote to sync workspace files with a repository.</div>
+            </div>
+            <div class="project-panel-section" id="projectFilesSection">
+                <label class="project-panel-label">Project Files</label>
+                <div id="projectFileList" class="project-panel-list"></div>
+                <div style="margin-top:6px">
+                    <input type="file" id="projectFileInput" style="display:none" multiple>
+                    <button class="btn-small" id="projectFileUploadBtn">Upload File</button>
+                </div>
+            </div>
             <div class="project-panel-section project-panel-footer">
                 <label class="project-panel-checkbox">
                     <input type="checkbox" id="projectArchiveToggle">
@@ -434,6 +454,15 @@ function _registerProjectPanel() {
     el.querySelector('#projectWsSelect').addEventListener('change', _saveProjectWorkspace);
     el.querySelector('#projectWsCreate').addEventListener('click', _createProjectWorkspace);
 
+    // Wire git settings (v0.22.4)
+    el.querySelector('#projectGitSave').addEventListener('click', _saveProjectGitConfig);
+
+    // Wire project files (v0.22.4)
+    el.querySelector('#projectFileUploadBtn').addEventListener('click', () => {
+        document.getElementById('projectFileInput').click();
+    });
+    el.querySelector('#projectFileInput').addEventListener('change', _handleProjectFileUpload);
+
     PanelRegistry.register('project', {
         element: el,
         label: 'Project',
@@ -481,6 +510,12 @@ async function _loadProjectPanel(projectId) {
 
     // Load workspace picker (v0.21.5)
     await _renderProjectWorkspace(projectId);
+
+    // Load git settings (v0.22.4) — depends on workspace being loaded
+    await _renderProjectGitSettings(projectId);
+
+    // Load project files (v0.22.4)
+    await _renderProjectFiles(projectId);
 }
 
 async function _saveProjectPrompt() {
@@ -700,6 +735,8 @@ async function _saveProjectWorkspace() {
         UI.toast(wsId ? 'Workspace linked' : 'Workspace unlinked', 'success');
         // Trigger editor surface check
         if (typeof EditorMode !== 'undefined') EditorMode.check();
+        // Refresh git settings (v0.22.4)
+        await _renderProjectGitSettings(_projectPanelId);
     } catch (e) {
         UI.toast('Failed to update workspace', 'error');
     }
@@ -731,6 +768,106 @@ async function _createProjectWorkspace() {
 
 // ── Channel workspace picker (v0.21.5) ───────
 
+// ── Workspace Git Config (v0.22.4) ───────────
+
+async function _renderProjectGitSettings(projectId) {
+    const gitSection = document.getElementById('projectGitSection');
+    const wsId = document.getElementById('projectWsSelect')?.value;
+    if (!wsId) {
+        gitSection.style.display = 'none';
+        return;
+    }
+    gitSection.style.display = '';
+
+    try {
+        const ws = await API.getWorkspace(wsId);
+        document.getElementById('projectGitRemote').value = ws.git_remote_url || '';
+        document.getElementById('projectGitBranch').value = ws.git_branch || '';
+
+        // Load git credentials
+        const credSel = document.getElementById('projectGitCredential');
+        credSel.innerHTML = '<option value="">No credential</option>';
+        try {
+            const creds = await API.listGitCredentials();
+            const list = Array.isArray(creds) ? creds : (creds?.data || []);
+            for (const c of list) {
+                const opt = document.createElement('option');
+                opt.value = c.id;
+                opt.textContent = c.name || c.id.slice(0, 8);
+                if (c.id === ws.git_credential_id) opt.selected = true;
+                credSel.appendChild(opt);
+            }
+        } catch (_) {}
+    } catch (_) {
+        gitSection.style.display = 'none';
+    }
+}
+
+async function _saveProjectGitConfig() {
+    const wsId = document.getElementById('projectWsSelect')?.value;
+    if (!wsId) return;
+
+    const remote = document.getElementById('projectGitRemote').value.trim();
+    const branch = document.getElementById('projectGitBranch').value.trim() || null;
+    const credId = document.getElementById('projectGitCredential').value || null;
+
+    try {
+        await API.updateWorkspace(wsId, {
+            git_remote_url: remote || null,
+            git_branch: branch,
+            git_credential_id: credId,
+        });
+        UI.toast('Git config saved', 'success');
+    } catch (e) {
+        UI.toast('Failed to save git config: ' + (e.message || e), 'error');
+    }
+}
+
+// ── Project Files (v0.22.4) ──────────────────
+
+async function _renderProjectFiles(projectId) {
+    const list = document.getElementById('projectFileList');
+    if (!list) return;
+
+    try {
+        const resp = await API.projectListFiles(projectId);
+        const files = resp?.files || [];
+        if (!files.length) {
+            list.innerHTML = '<div class="project-panel-empty">No files uploaded</div>';
+            return;
+        }
+        list.innerHTML = files.map(f => {
+            const size = f.size_bytes > 1024 * 1024
+                ? (f.size_bytes / 1024 / 1024).toFixed(1) + ' MB'
+                : (f.size_bytes / 1024).toFixed(1) + ' KB';
+            return `<div class="project-panel-item" style="display:flex;justify-content:space-between;align-items:center">
+                <span title="${esc(f.filename)}">${esc(f.filename)}</span>
+                <span class="text-muted" style="font-size:11px">${size}</span>
+            </div>`;
+        }).join('');
+    } catch (e) {
+        list.innerHTML = '<div class="project-panel-empty">Failed to load files</div>';
+    }
+}
+
+async function _handleProjectFileUpload() {
+    const input = document.getElementById('projectFileInput');
+    if (!input.files?.length || !_projectPanelId) return;
+
+    for (const file of input.files) {
+        try {
+            await API.projectUploadFile(_projectPanelId, file);
+            UI.toast(`Uploaded ${file.name}`, 'success');
+        } catch (e) {
+            UI.toast(`Upload failed: ${e.message || e}`, 'error');
+        }
+    }
+    input.value = '';
+    await _renderProjectFiles(_projectPanelId);
+}
+
+
+
 async function showWorkspacePicker(chatId) {
     let workspaces = [];
     try {
diff --git a/src/js/ui-admin.js b/src/js/ui-admin.js
index 8693cd8..84155ed 100644
--- a/src/js/ui-admin.js
+++ b/src/js/ui-admin.js
@@ -929,6 +929,10 @@ Object.assign(UI, {
                                 <span class="admin-storage-label">Timeouts</span>
                                 <span class="admin-storage-value">${p.timeout_count ?? 0}</span>
                             </div>
+                            <div class="admin-storage-item">
+                                <span class="admin-storage-label">Rate Limits</span>
+                                <span class="admin-storage-value" style="color:${(p.rate_limit_count || 0) > 0 ? 'var(--warning)' : 'inherit'}">${p.rate_limit_count ?? 0}</span>
+                            </div>
                             <div class="admin-storage-item">
                                 <span class="admin-storage-label">Max Latency</span>
                                 <span class="admin-storage-value">${p.max_latency_ms ?? 0}ms</span>