feat: Major UI/UX improvements and production readiness

## Features Added

### Document Reference System
- Implemented numbered document references (@1, @2, etc.) with autocomplete dropdown
- Added fuzzy filename matching for @filename references
- Document filtering now prioritizes numeric refs > filename refs > all documents
- Autocomplete dropdown appears when typing @ with keyboard navigation (Up/Down, Enter/Tab, Escape)
- Document numbers displayed in UI for easy reference

### Conversation Management
- Added conversation rename functionality with inline editing
- Implemented conversation search (by title and content)
- Search box always visible, even when no conversations exist
- Export reports now replace @N references with actual filenames

### UI/UX Improvements
- Removed debug toggle button
- Improved text contrast in dark mode (better visibility)
- Made input textarea expand to full available width
- Fixed file text color for better readability
- Enhanced document display with numbered badges

### Configuration & Timeouts
- Made HTTP client timeouts configurable (connect, write, pool)
- Added .env.example with all configuration options
- Updated timeout documentation

### Developer Experience
- Added `make test-setup` target for automated test conversation creation
- Test setup script supports TEST_MESSAGE and TEST_DOCS env vars
- Improved Makefile with dev and test-setup targets

### Documentation
- Updated ARCHITECTURE.md with all new features
- Created comprehensive deployment documentation
- Added GPU VM setup guides
- Removed unnecessary markdown files (CLAUDE.md, CONTRIBUTING.md, header.jpg)
- Organized documentation in docs/ directory

### GPU VM / Ollama (Stability + GPU Offload)
- Updated GPU VM docs to reflect the working systemd environment for remote Ollama
- Standardized remote Ollama port to 11434 (and added /v1/models verification)
- Documented required env for GPU offload on this VM:
  - `OLLAMA_MODELS=/mnt/data/ollama`, `HOME=/mnt/data/ollama/home`
  - `OLLAMA_LLM_LIBRARY=cuda_v12` (not `cuda`)
  - `LD_LIBRARY_PATH=/usr/local/lib/ollama:/usr/local/lib/ollama/cuda_v12`

## Technical Changes

### Backend
- Enhanced `docs_context.py` with reference parsing (numeric and filename)
- Added `update_conversation_title` to storage.py
- New endpoints: PATCH /api/conversations/{id}/title, GET /api/conversations/search
- Improved report generation with filename substitution

### Frontend
- Removed debugMode state and related code
- Added autocomplete dropdown component
- Implemented search functionality in Sidebar
- Enhanced ChatInterface with autocomplete and improved textarea sizing
- Updated CSS for better contrast and responsive design

## Files Changed
- Backend: config.py, council.py, docs_context.py, main.py, storage.py
- Frontend: App.jsx, ChatInterface.jsx, Sidebar.jsx, and related CSS files
- Documentation: README.md, ARCHITECTURE.md, new docs/ directory
- Configuration: .env.example, Makefile
- Scripts: scripts/test_setup.py

## Breaking Changes
None - all changes are backward compatible

## Testing
- All existing tests pass
- New test-setup script validates conversation creation workflow
- Manual testing of autocomplete, search, and rename features

backend/tests/test_config_env.py

@@ -0,0 +1,35 @@
+import importlib
+import os
+import unittest
+
+
+class TestConfigEnvOverrides(unittest.TestCase):
+    def setUp(self):
+        self._old_env = dict(os.environ)
+
+    def tearDown(self):
+        os.environ.clear()
+        os.environ.update(self._old_env)
+
+    def test_council_models_override_from_env_csv(self):
+        os.environ["COUNCIL_MODELS"] = "a,b, c"
+        import backend.config as config
+
+        importlib.reload(config)
+        self.assertEqual(config.COUNCIL_MODELS, ["a", "b", "c"])
+
+    def test_chairman_model_override(self):
+        os.environ["CHAIRMAN_MODEL"] = "chair"
+        import backend.config as config
+
+        importlib.reload(config)
+        self.assertEqual(config.CHAIRMAN_MODEL, "chair")
+
+    def test_max_tokens_override(self):
+        os.environ["MAX_TOKENS"] = "1234"
+        import backend.config as config
+
+        importlib.reload(config)
+        self.assertEqual(config.MAX_TOKENS, 1234)
+
+

backend/tests/test_doc_preview_truncation.py

@@ -0,0 +1,60 @@
+import importlib
+import os
+import shutil
+import tempfile
+import unittest
+
+import httpx
+
+
+class TestDocPreviewTruncation(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        self._old_env = dict(os.environ)
+        self.tmp = tempfile.mkdtemp(prefix="llm-council-docprev-")
+        os.environ["DOCS_DIR"] = self.tmp
+        os.environ["MAX_DOC_BYTES"] = "1000000"
+        os.environ["MAX_DOC_PREVIEW_CHARS"] = "10"
+
+        import backend.config as config
+        import backend.documents as documents
+        import backend.main as main
+
+        importlib.reload(config)
+        importlib.reload(documents)
+        self.main = importlib.reload(main)
+
+        self.client = httpx.AsyncClient(
+            transport=httpx.ASGITransport(app=self.main.app),
+            base_url="http://test",
+        )
+
+        # Create a conversation
+        resp = await self.client.post("/api/conversations", json={})
+        resp.raise_for_status()
+        self.conversation_id = resp.json()["id"]
+
+        # Upload a long doc
+        files = {"file": ("long.md", b"0123456789ABCDEFGHIJ", "text/markdown")}
+        up = await self.client.post(
+            f"/api/conversations/{self.conversation_id}/documents",
+            files=files,
+        )
+        up.raise_for_status()
+        self.doc_id = up.json()["id"]
+
+    async def asyncTearDown(self):
+        await self.client.aclose()
+        os.environ.clear()
+        os.environ.update(self._old_env)
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    async def test_preview_truncates(self):
+        resp = await self.client.get(
+            f"/api/conversations/{self.conversation_id}/documents/{self.doc_id}"
+        )
+        self.assertEqual(resp.status_code, 200)
+        content = resp.json()["content"]
+        self.assertEqual(len(content), 10)
+        self.assertTrue(content.endswith("..."))
+
+

backend/tests/test_docs_api.py

@@ -0,0 +1,110 @@
+import os
+import shutil
+import tempfile
+import unittest
+import importlib
+
+import httpx
+
+
+class TestDocumentsApi(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        self._old_env = dict(os.environ)
+        self.tmp = tempfile.mkdtemp(prefix="llm-council-docsapi-")
+        os.environ["DOCS_DIR"] = self.tmp
+        os.environ["MAX_DOC_BYTES"] = "1000000"
+
+        # Reload config/documents so they see DOCS_DIR override
+        import backend.config as config
+        import backend.documents as documents
+        import backend.main as main
+
+        importlib.reload(config)
+        importlib.reload(documents)
+        self.main = importlib.reload(main)
+
+        self.transport = httpx.ASGITransport(app=self.main.app)
+        self.client = httpx.AsyncClient(transport=self.transport, base_url="http://test")
+
+        # Create a conversation
+        resp = await self.client.post("/api/conversations", json={})
+        resp.raise_for_status()
+        self.conversation_id = resp.json()["id"]
+
+    async def asyncTearDown(self):
+        await self.client.aclose()
+        os.environ.clear()
+        os.environ.update(self._old_env)
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    async def test_upload_and_list_documents(self):
+        # Upload
+        files = {"file": ("notes.md", b"# Hi\n", "text/markdown")}
+        resp = await self.client.post(
+            f"/api/conversations/{self.conversation_id}/documents",
+            files=files,
+        )
+        self.assertEqual(resp.status_code, 200, resp.text)
+        meta = resp.json()
+        self.assertIn("id", meta)
+        self.assertEqual(meta["filename"], "notes.md")
+
+        # List
+        resp2 = await self.client.get(
+            f"/api/conversations/{self.conversation_id}/documents"
+        )
+        self.assertEqual(resp2.status_code, 200, resp2.text)
+        items = resp2.json()
+        self.assertEqual(len(items), 1)
+        self.assertEqual(items[0]["id"], meta["id"])
+
+    async def test_upload_multiple_documents(self):
+        files = [
+            ("files", ("a.md", b"one", "text/markdown")),
+            ("files", ("b.md", b"two", "text/markdown")),
+        ]
+        resp = await self.client.post(
+            f"/api/conversations/{self.conversation_id}/documents",
+            files=files,
+        )
+        self.assertEqual(resp.status_code, 200, resp.text)
+        payload = resp.json()
+        self.assertIn("uploaded", payload)
+        self.assertEqual(len(payload["uploaded"]), 2)
+        self.assertEqual({d["filename"] for d in payload["uploaded"]}, {"a.md", "b.md"})
+
+    async def test_rejects_non_md(self):
+        files = {"file": ("notes.txt", b"hello", "text/plain")}
+        resp = await self.client.post(
+            f"/api/conversations/{self.conversation_id}/documents",
+            files=files,
+        )
+        self.assertEqual(resp.status_code, 400)
+
+    async def test_get_and_delete_document(self):
+        files = {"file": ("a.md", b"hello", "text/markdown")}
+        up = await self.client.post(
+            f"/api/conversations/{self.conversation_id}/documents",
+            files=files,
+        )
+        self.assertEqual(up.status_code, 200)
+        doc_id = up.json()["id"]
+
+        get = await self.client.get(
+            f"/api/conversations/{self.conversation_id}/documents/{doc_id}"
+        )
+        self.assertEqual(get.status_code, 200)
+        self.assertEqual(get.json()["content"], "hello")
+
+        dele = await self.client.delete(
+            f"/api/conversations/{self.conversation_id}/documents/{doc_id}"
+        )
+        self.assertEqual(dele.status_code, 200)
+        self.assertTrue(dele.json()["ok"])
+
+        get2 = await self.client.get(
+            f"/api/conversations/{self.conversation_id}/documents/{doc_id}"
+        )
+        self.assertEqual(get2.status_code, 404)
+
+

backend/tests/test_docs_context.py

@@ -0,0 +1,38 @@
+import os
+import shutil
+import tempfile
+import unittest
+import importlib
+
+
+class TestDocsContext(unittest.TestCase):
+    def setUp(self):
+        self._old_env = dict(os.environ)
+        self.tmp = tempfile.mkdtemp(prefix="llm-council-docsctx-")
+        os.environ["DOCS_DIR"] = self.tmp
+        os.environ["MAX_DOC_BYTES"] = "1000000"
+
+        import backend.config as config
+        import backend.documents as documents
+        import backend.docs_context as docs_context
+
+        self.config = importlib.reload(config)
+        self.documents = importlib.reload(documents)
+        self.docs_context = importlib.reload(docs_context)
+
+    def tearDown(self):
+        os.environ.clear()
+        os.environ.update(self._old_env)
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def test_build_docs_context_truncates(self):
+        conv = "c1"
+        self.documents.save_markdown_document(conv, "a.md", b"A" * 50)
+        self.documents.save_markdown_document(conv, "b.md", b"B" * 50)
+
+        ctx = self.docs_context.build_docs_context(conv, max_chars=60, max_docs=5)
+        self.assertIsNotNone(ctx)
+        self.assertIn("DOC:", ctx)
+        self.assertTrue(len(ctx) <= 60)
+
+

backend/tests/test_documents.py

@@ -0,0 +1,48 @@
+import os
+import shutil
+import tempfile
+import unittest
+import importlib
+
+
+class TestDocumentsStorage(unittest.TestCase):
+    def setUp(self):
+        self._old_env = dict(os.environ)
+        self.tmp = tempfile.mkdtemp(prefix="llm-council-docs-")
+        os.environ["DOCS_DIR"] = self.tmp
+        os.environ["MAX_DOC_BYTES"] = "100"
+
+        import backend.config as config
+        import backend.documents as documents
+
+        self.config = importlib.reload(config)
+        self.documents = importlib.reload(documents)
+
+    def tearDown(self):
+        os.environ.clear()
+        os.environ.update(self._old_env)
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def test_save_and_list_document(self):
+        meta = self.documents.save_markdown_document(
+            "conv1",
+            "../weird/name.md",
+            b"# Hello\n",
+        )
+        self.assertTrue(meta.id)
+        self.assertEqual(meta.filename, "name.md")
+        self.assertEqual(meta.bytes, 8)
+
+        listed = self.documents.list_documents("conv1")
+        self.assertEqual(len(listed), 1)
+        self.assertEqual(listed[0].id, meta.id)
+        self.assertEqual(listed[0].filename, "name.md")
+
+        text = self.documents.read_document_text("conv1", meta.id)
+        self.assertIn("# Hello", text)
+
+    def test_rejects_too_large(self):
+        with self.assertRaises(ValueError):
+            self.documents.save_markdown_document("conv1", "a.md", b"x" * 101)
+
+

backend/tests/test_llm_client.py

@@ -0,0 +1,65 @@
+import os
+import unittest
+
+
+class TestProviderSelection(unittest.TestCase):
+    def setUp(self):
+        self._old_env = dict(os.environ)
+
+    def tearDown(self):
+        os.environ.clear()
+        os.environ.update(self._old_env)
+
+    def test_always_returns_openai_compat(self):
+        """Provider is always 'openai_compat' now (OpenRouter removed)."""
+        from backend.llm_client import _get_provider_name
+
+        # Should always return openai_compat regardless of env vars
+        self.assertEqual(_get_provider_name(), "openai_compat")
+        
+        # Test with different env var combinations
+        os.environ["OPENAI_COMPAT_BASE_URL"] = "http://gpu:8000"
+        self.assertEqual(_get_provider_name(), "openai_compat")
+        
+        os.environ.pop("OPENAI_COMPAT_BASE_URL", None)
+        self.assertEqual(_get_provider_name(), "openai_compat")
+
+
+class TestParallelConcurrency(unittest.IsolatedAsyncioTestCase):
+    async def test_query_models_parallel_respects_llm_max_concurrency(self):
+        import asyncio
+        import backend.llm_client as lc
+
+        old_env = dict(os.environ)
+        old_query_model = lc.query_model
+
+        in_flight = 0
+        max_in_flight = 0
+        lock = asyncio.Lock()
+
+        async def fake_query_model(model, messages, timeout=120.0, max_tokens_override=None):
+            nonlocal in_flight, max_in_flight
+            async with lock:
+                in_flight += 1
+                max_in_flight = max(max_in_flight, in_flight)
+            # ensure overlap is possible without the semaphore
+            await asyncio.sleep(0.02)
+            async with lock:
+                in_flight -= 1
+            return {"content": model}
+
+        try:
+            os.environ["LLM_MAX_CONCURRENCY"] = "1"
+            lc.query_model = fake_query_model
+
+            models = ["m1", "m2", "m3"]
+            out = await lc.query_models_parallel(models, [{"role": "user", "content": "hi"}])
+
+            self.assertEqual(set(out.keys()), set(models))
+            self.assertEqual(max_in_flight, 1)
+        finally:
+            lc.query_model = old_query_model
+            os.environ.clear()
+            os.environ.update(old_env)
+
+

backend/tests/test_llm_status.py

@@ -0,0 +1,36 @@
+import importlib
+import os
+import unittest
+
+import httpx
+
+
+class TestLlmStatusEndpoint(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        self._old_env = dict(os.environ)
+        os.environ["OPENAI_COMPAT_BASE_URL"] = "http://localhost:11434"
+        os.environ.pop("USE_LOCAL_OLLAMA", None)  # Clear this so OPENAI_COMPAT_BASE_URL is used
+
+        import backend.config as config
+        import backend.main as main
+
+        importlib.reload(config)  # Reload config to pick up env changes
+        self.main = importlib.reload(main)
+        self.client = httpx.AsyncClient(
+            transport=httpx.ASGITransport(app=self.main.app),
+            base_url="http://test",
+        )
+
+    async def asyncTearDown(self):
+        await self.client.aclose()
+        os.environ.clear()
+        os.environ.update(self._old_env)
+
+    async def test_status_without_probe(self):
+        resp = await self.client.get("/api/llm/status")
+        self.assertEqual(resp.status_code, 200)
+        data = resp.json()
+        self.assertEqual(data["provider"], "openai_compat")
+        self.assertEqual(data["base_url"], "http://localhost:11434")
+
+

backend/tests/test_openai_compat.py

@@ -0,0 +1,87 @@
+import unittest
+
+import httpx
+import json
+
+from backend.openai_compat import _resolve_chat_completions_url, _resolve_models_url, query_model, list_models
+
+
+class TestOpenAICompatUrl(unittest.TestCase):
+    def test_resolve_url_when_no_v1(self):
+        self.assertEqual(
+            _resolve_chat_completions_url("http://gpu:8000"),
+            "http://gpu:8000/v1/chat/completions",
+        )
+
+    def test_resolve_url_when_v1(self):
+        self.assertEqual(
+            _resolve_chat_completions_url("http://gpu:8000/v1"),
+            "http://gpu:8000/v1/chat/completions",
+        )
+
+    def test_resolve_url_when_v1_with_trailing_slash(self):
+        self.assertEqual(
+            _resolve_chat_completions_url("http://gpu:8000/v1/"),
+            "http://gpu:8000/v1/chat/completions",
+        )
+
+    def test_resolve_models_url(self):
+        self.assertEqual(
+            _resolve_models_url("http://gpu:8000"),
+            "http://gpu:8000/v1/models",
+        )
+
+
+class TestOpenAICompatRequest(unittest.IsolatedAsyncioTestCase):
+    async def test_query_model_builds_payload_and_parses_response(self):
+        captured = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            captured["url"] = str(request.url)
+            captured["auth"] = request.headers.get("authorization")
+            captured["json"] = json.loads(request.content.decode("utf-8"))
+            return httpx.Response(
+                200,
+                json={
+                    "choices": [
+                        {
+                            "message": {"content": "hello", "reasoning_details": None},
+                        }
+                    ]
+                },
+            )
+
+        transport = httpx.MockTransport(handler)
+        async with httpx.AsyncClient(transport=transport, timeout=10.0) as client:
+            out = await query_model(
+                "my-model",
+                [{"role": "user", "content": "hi"}],
+                base_url="http://gpu:8000",
+                api_key="secret",
+                max_tokens=123,
+                timeout=10.0,
+                client=client,
+            )
+
+        self.assertEqual(captured["url"], "http://gpu:8000/v1/chat/completions")
+        self.assertEqual(captured["auth"], "Bearer secret")
+        self.assertEqual(captured["json"]["model"], "my-model")
+        self.assertEqual(captured["json"]["max_tokens"], 123)
+        self.assertEqual(out["content"], "hello")
+
+    async def test_list_models_parses_ids(self):
+        def handler(request: httpx.Request) -> httpx.Response:
+            return httpx.Response(
+                200,
+                json={"data": [{"id": "a"}, {"id": "b"}, {"nope": "c"}]},
+            )
+
+        transport = httpx.MockTransport(handler)
+        async with httpx.AsyncClient(transport=transport, timeout=10.0) as client:
+            ids = await list_models(
+                base_url="http://gpu:8000",
+                client=client,
+            )
+        self.assertEqual(ids, ["a", "b"])
+
+