Your lightweight open-source personal agent.
Python agent-frameworkai-agentai-agentschatbotchatopsdiscord-botllm-agentsllmslocal-llmmcpmodel-context-protocolmulti-agentopenai-compatibleopenclawpersonal-ai-assistantpythonself-hostedtelegram-bot-ai-assistantwebuiworkflow-automation
refactor(sessions): persist archive state in SQLite (#6536)
chengyongru80ac41b1f4a6
diff --git a/nanobot/channels/websocket/tests/test_websocket_channel.py b/nanobot/channels/websocket/tests/test_websocket_channel.pyindex c59d21519..e168a5b60 100644--- a/nanobot/channels/websocket/tests/test_websocket_channel.py+++ b/nanobot/channels/websocket/tests/test_websocket_channel.py@@ -1579,66 +1579,63 @@ async def test_webui_persists_sidebar_state_larger_than_http_request_line("event": "webui_response","request_id": request_id,"ok": True,- "result": saved,+ "result": {**saved, "archived_keys": []},}@pytest.mark.asyncio[email protected]("command_type", ["webui_request", "set_sidebar_state"])async def test_webui_sidebar_state_update_broadcasts_workbench_to_other_devices(bus: MagicMock,tmp_path: Path,monkeypatch: pytest.MonkeyPatch,+ command_type: str,) -> None:monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)- channel = _ch(bus)+ sessions = SessionManager(tmp_path)+ await sessions.state.import_messages("websocket:a", [{"role": "user", "content": "saved"}])+ await sessions.state.fork("websocket:a", "websocket:b", 0)+ sessions.get_or_create("websocket:draft")+ channel = _ch(bus, session_manager=sessions)source = AsyncMock()source.request = SimpleNamespace(headers=Headers())other_device = AsyncMock()channel._webui_connections.update({source, other_device})channel._register_connection_outbound(other_device)- request_id = "sidebar-workbench-state"-- await channel._dispatch_envelope(- source,- "webui-client",- {- "type": "webui_request",- "request_id": request_id,- "action": "sidebar.update",- "payload": {- "state": {- "workbench": {- "version": 1,- "tabs": {- "tab:websocket:a": {- "explicit": True,- "title": "Research",- "paneKeys": ["websocket:a", "websocket:b"],- "layoutPaneKeys": ["websocket:b", "websocket:a"],- "layout": "columns",- "splitRatios": [0.35],- }- },- }+ state = {+ "archived_keys": ["websocket:b", "websocket:draft"],+ "workbench": {+ "version": 1,+ "tabs": {+ "tab:websocket:a": {+ "explicit": True,+ "title": "Research",+ "paneKeys": ["websocket:a", "websocket:b"],+ "layoutPaneKeys": ["websocket:b", "websocket:a"],+ "layout": "columns",+ "splitRatios": [0.35],}},},- )- await asyncio.gather(*tuple(channel._webui_request_tasks.values()))-- event = json.loads(other_device.send.await_args.args[0])- assert event["event"] == "sidebar_state_updated"- assert event["state"]["workbench"]["tabs"]["tab:websocket:a"]["paneKeys"] == [- "websocket:a",- "websocket:b",- ]- assert event["state"]["workbench"]["tabs"]["tab:websocket:a"]["layoutPaneKeys"] == [- "websocket:b",- "websocket:a",- ]- assert event["state"]["workbench"]["tabs"]["tab:websocket:a"]["splitRatios"] == [- 0.35- ]+ }+ envelope = {"type": command_type, "state": state} if command_type == "set_sidebar_state" else {+ "type": command_type, "request_id": "sidebar-workbench-state",+ "action": "sidebar.update", "payload": {"state": state},+ }+ try:+ await channel._dispatch_envelope(source, "webui-client", envelope)+ await asyncio.gather(*tuple(channel._webui_request_tasks.values()))+ event = json.loads(other_device.send.await_args.args[0])+ assert event["event"] == "sidebar_state_updated"+ assert event["state"]["archived_keys"] == ["websocket:b"]+ assert await sessions.state.archived_keys() == ["websocket:b"]+ assert event["state"]["workbench"] == state["workbench"]+ persisted = json.loads((tmp_path / "webui" / "sidebar-state.json").read_text(encoding="utf-8"))+ assert "archived_keys" not in persisted+ assert persisted["workbench"] == state["workbench"]+ finally:+ await channel.stop()+ await sessions.state.aclose()@pytest.mark.asynciodiff --git a/nanobot/channels/websocket/tests/test_websocket_http_routes.py b/nanobot/channels/websocket/tests/test_websocket_http_routes.pyindex e0d91e361..71f589d52 100644--- a/nanobot/channels/websocket/tests/test_websocket_http_routes.py+++ b/nanobot/channels/websocket/tests/test_websocket_http_routes.py@@ -2442,6 +2442,8 @@ async def test_webui_sidebar_state_routes_are_config_dir_scoped() -> None:monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)sm = _seed_session(tmp_path, key="websocket:sidebar")+ await sm.state.fork("websocket:sidebar", "websocket:old", 0)+ sm.get_or_create("websocket:draft")channel = _ch(bus, session_manager=sm, port=29911)server_task = asyncio.create_task(channel.start())try:@@ -2458,7 +2460,7 @@ async def test_webui_sidebar_state_routes_are_config_dir_scoped(payload = {"pinned_keys": ["websocket:sidebar"],- "archived_keys": ["websocket:old"],+ "archived_keys": ["websocket:old", "websocket:draft"],"session_order": ["websocket:old", "websocket:sidebar"],"title_overrides": {"websocket:sidebar": "Pinned work"},"view": {"density": "compact", "show_archived": True},@@ -2471,15 +2473,19 @@ async def test_webui_sidebar_state_routes_are_config_dir_scoped(assert updated.status_code == 200body = updated.json()assert body["pinned_keys"] == ["websocket:sidebar"]+ assert body["archived_keys"] == ["websocket:old"]+ assert await sm.state.archived_keys() == ["websocket:old"]assert body["session_order"] == ["websocket:old", "websocket:sidebar"]assert body["title_overrides"] == {"websocket:sidebar": "Pinned work"}assert body["view"]["density"] == "compact"state_path = tmp_path / "webui" / "sidebar-state.json"assert state_path.is_file()- assert json.loads(state_path.read_text(encoding="utf-8"))["pinned_keys"] == [- "websocket:sidebar"- ]+ persisted = json.loads(state_path.read_text(encoding="utf-8"))+ assert persisted["pinned_keys"] == ["websocket:sidebar"]+ assert "archived_keys" not in persisted+ read_back = await _http_get("http://127.0.0.1:29911/api/webui/sidebar-state", headers=auth)+ assert read_back.json()["archived_keys"] == ["websocket:old"]finally:await channel.stop()await server_taskdiff --git a/nanobot/cli/gateway_runtime.py b/nanobot/cli/gateway_runtime.pyindex f71e61a41..377bf1d51 100644--- a/nanobot/cli/gateway_runtime.py+++ b/nanobot/cli/gateway_runtime.py@@ -56,7 +56,7 @@ from nanobot.utils.helpers import sync_workspace_templatesfrom nanobot.utils.token_encoding import warmup_token_encodingfrom nanobot.webui.build import BuildModefrom nanobot.webui.dev import WebUIDevError, WebUIDevServer-from nanobot.webui.sidebar_state import read_webui_sidebar_state+from nanobot.webui.sidebar_state import ensure_webui_session_archivesif TYPE_CHECKING:from nanobot.update_profiles import ProfileReceipt@@ -829,7 +829,7 @@ def _run_claimed_gateway()async def _pick_heartbeat_target() -> tuple[str, str]:- sidebar_state = await asyncio.to_thread(read_webui_sidebar_state)+ archived_keys = await ensure_webui_session_archives(session_manager.state)unified_metadata = Noneif config.agents.defaults.unified_session:record = await session_manager.state.read_metadata(UNIFIED_SESSION_KEY)@@ -838,7 +838,7 @@ def _run_claimed_gateway(return _pick_heartbeat_target_from_sessions(enabled_channels=channels.enabled_channels,sessions=await session_manager.state.list_sessions(),- archived_keys=sidebar_state.get("archived_keys", []),+ archived_keys=archived_keys,unified_session_metadata=unified_metadata,)diff --git a/nanobot/session/sqlite_store.py b/nanobot/session/sqlite_store.pyindex 09555e142..fd8e3b36d 100644--- a/nanobot/session/sqlite_store.py+++ b/nanobot/session/sqlite_store.py@@ -94,9 +94,29 @@ def _create_schema_v2(db: sqlite3.Connection) -> None:db.execute(statement)+def _create_schema_v3(db: sqlite3.Connection) -> None:+ # Empty chats can be archived before their first persisted message.+ db.execute("""CREATE TABLE session_archives (+ key TEXT PRIMARY KEY, archived_at TEXT NOT NULL+ )""")+++def _create_schema_v4(db: sqlite3.Connection) -> None:+ db.execute("""CREATE TABLE session_archives_v4 (+ key TEXT PRIMARY KEY REFERENCES sessions(key)+ ON DELETE NO ACTION DEFERRABLE INITIALLY DEFERRED,+ archived_at TEXT NOT NULL+ )""")+ db.execute("""INSERT INTO session_archives_v4 (key, archived_at)+ SELECT archives.key, archives.archived_at FROM session_archives AS archives+ JOIN sessions ON sessions.key = archives.key""")+ db.execute("DROP TABLE session_archives")+ db.execute("ALTER TABLE session_archives_v4 RENAME TO session_archives")++# Entries upgrade version N to N+1. Preserve released entries and append upgrades._SCHEMA_MIGRATIONS: tuple[Callable[[sqlite3.Connection], None], ...] = (- _create_schema_v1, _create_schema_v2,+ _create_schema_v1, _create_schema_v2, _create_schema_v3, _create_schema_v4,)@@ -475,9 +495,47 @@ class SqliteSessionStore:return True- def delete(self, key: str) -> bool:+ def archives_imported(self) -> bool:+ with self.transaction(write=False) as db:+ return db.execute("SELECT 1 FROM storage_meta WHERE key='session_archives_imported'").fetchone() is not None++ def archived_keys(self) -> list[str]:+ with self.transaction(write=False) as db:+ encoded = db.execute("SELECT json_group_array(key) FROM (SELECT key FROM session_archives ORDER BY key)").fetchone()[0]+ return cast(list[str], json.loads(encoded))++ def import_archives(self, keys: list[str]) -> list[str]:+ with self.transaction() as db:+ if self.archives_imported():+ return self.archived_keys()+ imported = self.set_archived_keys(keys)+ db.execute("INSERT INTO storage_meta (key, value) VALUES ('session_archives_imported', '1')")+ return imported++ def set_archived_keys(self, keys: list[str]) -> list[str]:+ with self.transaction() as db:+ current = set(self.archived_keys())+ requested = set(keys)+ # Existing memberships are valid by FK; only new keys need validation.+ added = requested - current+ if added:+ added = {row[0] for row in db.execute(+ "SELECT key FROM sessions WHERE key IN (SELECT value FROM json_each(?))",+ (_encode(list(added)),),+ )}+ target = (requested & current) | added+ db.executemany("DELETE FROM session_archives WHERE key=?", ((key,) for key in current - target))+ now = datetime.now().isoformat()+ db.executemany("INSERT INTO session_archives (key, archived_at) VALUES (?, ?)", ((key, now) for key in target - current))+ return sorted(target)++ def delete(self, key: str, *, preserve_archive: bool = False) -> bool:with self.transaction() as db:- return db.execute("DELETE FROM sessions WHERE key=?", (key,)).rowcount > 0+ archived = False+ if not preserve_archive:+ archived = db.execute("DELETE FROM session_archives WHERE key=?", (key,)).rowcount > 0+ deleted = db.execute("DELETE FROM sessions WHERE key=?", (key,)).rowcount > 0+ return archived or deleteddef list_sessions(self) -> list[SessionInfo]:with self.transaction(write=False) as db:diff --git a/nanobot/session/state.py b/nanobot/session/state.pyindex 6134c7d0b..4f64e35b7 100644--- a/nanobot/session/state.py+++ b/nanobot/session/state.py@@ -83,6 +83,8 @@ class SessionState:thread_name_prefix="session-write",)self._closed = False+ # Import completion is permanent; archive contents are never cached.+ self._archives_imported = Falseself._close_task: asyncio.Task[None] | None = Noneself._loop: asyncio.AbstractEventLoop | None = None@@ -121,12 +123,14 @@ class SessionState:*,operation_name: str | None = None,write: bool = True,+ barrier: bool = True,) -> _T:async def run() -> _T:return await self._run_operation(operation, write=write)return await self._submit(key, run, operation_name=operation_name or getattr(operation, "__name__", "session operation"),+ barrier=barrier,)async def _submit(@@ -817,6 +821,34 @@ class SessionState:write=False,)+ async def archives_imported(self) -> bool:+ if not self._archives_imported and await self._execute(+ None, self._store.archives_imported, operation_name="archives_imported",+ write=False, barrier=False,+ ):+ self._archives_imported = True+ return self._archives_imported++ async def archived_keys(self) -> list[str]:+ return await self._execute(+ None, self._store.archived_keys, operation_name="archived_keys",+ write=False, barrier=False,+ )++ async def import_archives(self, keys: Sequence[str]) -> list[str]:+ values = list(keys)+ imported = await self._execute(+ None, lambda: self._store.import_archives(values), operation_name="import_archives",+ )+ self._archives_imported = True+ return imported++ async def set_archived_keys(self, keys: Sequence[str]) -> list[str]:+ values = list(dict.fromkeys(keys))+ return await self._execute(+ None, lambda: self._store.set_archived_keys(values), operation_name="set_archived_keys",+ )+async def list_sessions(self) -> list[dict[str, Any]]:return await self._execute(None,@@ -1114,7 +1146,7 @@ class SessionState:for name in (*_RESERVED_KEYS, "webui_recovery", "_last_summary", "_stopped_at_iteration_limit"):session.metadata.pop(name, None)if session.policy.persist:- self._store.delete(key)+ self._store.delete(key, preserve_archive=True)self._commit(session)return sessiondiff --git a/nanobot/webui/inbound_commands.py b/nanobot/webui/inbound_commands.pyindex 53afc302e..88eb996c1 100644--- a/nanobot/webui/inbound_commands.py+++ b/nanobot/webui/inbound_commands.py@@ -60,7 +60,6 @@ from nanobot.webui.session_access import (session_mentions_runtime_context,)from nanobot.webui.session_identity import is_valid_webui_chat_id, webui_session_key-from nanobot.webui.sidebar_state import write_webui_sidebar_statefrom nanobot.webui.temporary_chats import TemporaryChatErrorfrom nanobot.webui.transcription_ws import webui_transcription_event@@ -405,10 +404,7 @@ class WebUICommandRouter:)returntry:- saved_state = await asyncio.to_thread(- write_webui_sidebar_state,- cast(dict[str, Any], state),- )+ saved_state = await self._http_router.sidebar_state.write(cast(dict[str, Any], state))except (OSError, ValueError):await self._transport.webui_send_event(connection,diff --git a/nanobot/webui/sidebar_state.py b/nanobot/webui/sidebar_state.pyindex 5248898ff..be48fd208 100644--- a/nanobot/webui/sidebar_state.py+++ b/nanobot/webui/sidebar_state.py@@ -1,23 +1,29 @@-"""Persisted WebUI sidebar workspace state.+"""Compose sidebar preferences with session archive state.-This state is UI-only metadata, scoped to the active nanobot instance data-directory (the directory containing the current config.json). It deliberately-does not modify agent sessions.+Layout and display preferences stay in the config-scoped JSON file. Archive+flags live in the session database; the public sidebar payload combines both."""from __future__ import annotations+import asyncioimport jsonimport mathimport osimport threadingimport time+from collections.abc import AsyncGenerator+from contextlib import asynccontextmanagerfrom pathlib import Path-from typing import Any, cast+from typing import TYPE_CHECKING, Any, castfrom loguru import loggerfrom nanobot.config.paths import get_webui_dir+from nanobot.utils.cancellation import shield_and_drain++if TYPE_CHECKING:+ from nanobot.session.state import SessionStateWEBUI_SIDEBAR_STATE_SCHEMA_VERSION = 1_MAX_STATE_FILE_BYTES = 256 * 1024@@ -41,7 +47,6 @@ def default_webui_sidebar_state() -> dict[str, Any]:return {"schema_version": WEBUI_SIDEBAR_STATE_SCHEMA_VERSION,"pinned_keys": [],- "archived_keys": [],"session_order": [],"title_overrides": {},"project_name_overrides": {},@@ -202,7 +207,6 @@ def normalize_webui_sidebar_state(raw: Any) -> dict[str, Any]:raw = cast(dict[str, Any], raw)state = default_webui_sidebar_state()state["pinned_keys"] = _clean_string_list(raw.get("pinned_keys"))- state["archived_keys"] = _clean_string_list(raw.get("archived_keys"))state["session_order"] = _clean_string_list(raw.get("session_order"))state["title_overrides"] = _clean_title_overrides(raw.get("title_overrides"))state["project_name_overrides"] = _clean_title_overrides(@@ -233,13 +237,64 @@ def read_webui_sidebar_state() -> dict[str, Any]:return normalize_webui_sidebar_state(raw)+def read_legacy_archived_keys() -> list[str]:+ """Do not mark the import complete when the source cannot be read."""+ path = webui_sidebar_state_path()+ try:+ with path.open(encoding="utf-8") as source:+ raw = json.load(source)+ except FileNotFoundError:+ return []+ if not isinstance(raw, dict):+ raise ValueError("sidebar state must be an object")+ return _clean_string_list(cast(dict[str, Any], raw).get("archived_keys"))+++def remove_legacy_archived_keys() -> None:+ with _SIDEBAR_STATE_WRITE_LOCK:+ path = webui_sidebar_state_path()+ try:+ with path.open(encoding="utf-8") as source:+ raw = json.load(source)+ except FileNotFoundError:+ return+ if isinstance(raw, dict) and "archived_keys" in raw:+ _write_webui_sidebar_state(cast(dict[str, Any], raw))++def write_webui_sidebar_state(raw: dict[str, Any]) -> dict[str, Any]:with _SIDEBAR_STATE_WRITE_LOCK:return _write_webui_sidebar_state(raw)+def write_webui_sidebar_preferences(raw: dict[str, Any]) -> dict[str, Any]:+ """Archive-only changes must not rewrite the unchanged preference file."""+ with _SIDEBAR_STATE_WRITE_LOCK:+ target = normalize_webui_sidebar_state(raw)+ current: object = None+ try:+ with webui_sidebar_state_path().open("rb") as source:+ encoded = source.read(_MAX_STATE_FILE_BYTES + 1)+ if len(encoded) <= _MAX_STATE_FILE_BYTES:+ current = json.loads(encoded)+ except (OSError, ValueError):+ # Comparison is optional; the normal write still validates and+ # reports errors, and can replace a missing or damaged file.+ pass+ if isinstance(current, dict) and "archived_keys" not in current:+ previous_timestamp = cast(dict[str, Any], current).get("updated_at")+ if previous_timestamp is None or isinstance(previous_timestamp, str):+ target["updated_at"] = previous_timestamp+ if target == current:+ return target+ return _persist_webui_sidebar_state(target)++def _write_webui_sidebar_state(raw: dict[str, Any]) -> dict[str, Any]:- state = normalize_webui_sidebar_state(raw)+ return _persist_webui_sidebar_state(normalize_webui_sidebar_state(raw))+++def _persist_webui_sidebar_state(state: dict[str, Any]) -> dict[str, Any]:state["updated_at"] = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())encoded = json.dumps(state,@@ -268,3 +323,75 @@ def _write_webui_sidebar_state(raw: dict[str, Any]) -> dict[str, Any]:finally:os.close(dir_fd)return state+++async def ensure_webui_archives_imported(sessions: SessionState) -> None:+ if not await sessions.archives_imported():+ legacy = await asyncio.to_thread(read_legacy_archived_keys)+ await sessions.import_archives(legacy)+ await asyncio.to_thread(remove_legacy_archived_keys)+++async def ensure_webui_session_archives(sessions: SessionState) -> list[str]:+ await ensure_webui_archives_imported(sessions)+ return await sessions.archived_keys()+++class WebUISidebarState:+ def __init__(self, sessions: SessionState | None) -> None:+ self._sessions = sessions+ self._lock = asyncio.Lock()+ self._readers = 0+ self._readers_drained = asyncio.Event()+ self._readers_drained.set()++ @asynccontextmanager+ async def _read_snapshot(self) -> AsyncGenerator[None, None]:+ # The FIFO admission lock lets readers overlap without overtaking a writer.+ async with self._lock:+ self._readers += 1+ self._readers_drained.clear()+ try:+ yield+ finally:+ self._readers -= 1+ if not self._readers:+ self._readers_drained.set()++ async def read(self) -> dict[str, Any]:+ async with self._read_snapshot():+ if self._sessions is None:+ preferences = await asyncio.to_thread(read_webui_sidebar_state)+ return {**preferences, "archived_keys": []}+ await ensure_webui_archives_imported(self._sessions)+ preferences, archived = await asyncio.gather(+ asyncio.to_thread(read_webui_sidebar_state), self._sessions.archived_keys(),+ )+ return {**preferences, "archived_keys": archived}++ async def write(self, raw: dict[str, Any]) -> dict[str, Any]:+ # Keep each successful wire snapshot ordered across the two stores.+ async with self._lock:+ await self._readers_drained.wait()+ return await shield_and_drain(self._write_snapshot(raw))++ async def _write_snapshot(self, raw: dict[str, Any]) -> dict[str, Any]:+ if self._sessions is None:+ preferences = await asyncio.to_thread(write_webui_sidebar_preferences, raw)+ return {**preferences, "archived_keys": []}+ await ensure_webui_archives_imported(self._sessions)+ preferences, archived = await asyncio.gather(+ asyncio.to_thread(write_webui_sidebar_preferences, raw), self._sessions.archived_keys(),+ return_exceptions=True,+ )+ # Settle both branches before releasing admission, including failed reads.+ if isinstance(preferences, BaseException):+ raise preferences+ if isinstance(archived, BaseException):+ raise archived+ if "archived_keys" in raw:+ target = _clean_string_list(raw["archived_keys"])+ # Unchanged flags complete at the committed read, without a writer.+ if set(target) != set(archived):+ archived = await self._sessions.set_archived_keys(target)+ return {**preferences, "archived_keys": archived}diff --git a/nanobot/webui/ws_http.py b/nanobot/webui/ws_http.pyindex 2212f8e9f..984502b1c 100644--- a/nanobot/webui/ws_http.py+++ b/nanobot/webui/ws_http.py@@ -112,8 +112,8 @@ from nanobot.webui.session_list_index import (list_webui_sessions,)from nanobot.webui.sidebar_state import (- read_webui_sidebar_state,- write_webui_sidebar_state,+ WebUISidebarState,+ ensure_webui_archives_imported,)from nanobot.webui.skills_api import (SkillManagementError,@@ -395,6 +395,7 @@ class GatewayHTTPHandler:) -> None:self.config = configself.session_manager = session_manager+ self.sidebar_state = WebUISidebarState(session_manager.state if session_manager is not None else None)self.static_dist_path = static_dist_pathself.runtime_model_name = runtime_model_nameself.bus = bus@@ -1370,6 +1371,7 @@ class GatewayHTTPHandler:"automations": serialize_automation_jobs(automation_jobs),})+ await ensure_webui_archives_imported(self.session_manager.state)if automation_jobs:for job in automation_jobs:if isinstance(job, LocalTrigger):@@ -1707,9 +1709,9 @@ class GatewayHTTPHandler:return _http_error(500, "failed to save reminder preference")return _http_json_response({"show": show})if got == "/api/webui/sidebar-state":- return self._handle_webui_sidebar_state(request)+ return await self._handle_webui_sidebar_state(request)if got == "/api/webui/sidebar-state/update":- return self._handle_webui_sidebar_state_update(request)+ return await self._handle_webui_sidebar_state_update(request)return Nonedef _handle_commands(self, request: WsRequest) -> Response:@@ -1951,12 +1953,17 @@ class GatewayHTTPHandler:return _http_error(404, "skill not found")return _http_json_response(payload)- def _handle_webui_sidebar_state(self, request: WsRequest) -> Response:+ async def _handle_webui_sidebar_state(self, request: WsRequest) -> Response:if not self.check_api_token(request):return _http_error(401, "Unauthorized")- return _http_json_response(read_webui_sidebar_state())+ try:+ state = await self.sidebar_state.read()+ except (OSError, ValueError):+ self._log.exception("failed to read webui sidebar state")+ return _http_error(500, "failed to read sidebar state")+ return _http_json_response(state)- def _handle_webui_sidebar_state_update(self, request: WsRequest) -> Response:+ async def _handle_webui_sidebar_state_update(self, request: WsRequest) -> Response:if not self.check_api_token(request):return _http_error(401, "Unauthorized")payload = _mutation_payload(request)@@ -1966,7 +1973,7 @@ class GatewayHTTPHandler:if not isinstance(state_value, dict):return _http_error(400, "state must be an object")try:- state = write_webui_sidebar_state(cast(dict[str, Any], state_value))+ state = await self.sidebar_state.write(cast(dict[str, Any], state_value))except ValueError as e:return _http_error(400, str(e))except OSError:diff --git a/tests/cli/test_commands.py b/tests/cli/test_commands.pyindex d42f5def8..47455e602 100644--- a/tests/cli/test_commands.py+++ b/tests/cli/test_commands.py@@ -2250,7 +2250,7 @@ def test_heartbeat_empty_response_is_not_evaluated()monkeypatch.setattr("nanobot.cli.gateway_runtime.AgentLoop", _FakeAgentLoop)monkeypatch.setattr("nanobot.channels.manager.ChannelManager", _FakeChannelManager)- monkeypatch.setattr("nanobot.cli.gateway_runtime.read_webui_sidebar_state", lambda: {})+ monkeypatch.setattr("nanobot.cli.gateway_runtime.ensure_webui_session_archives", AsyncMock(return_value=[]))monkeypatch.setattr("nanobot.cli.gateway_runtime.evaluate_response", _unexpected_evaluator)result = runner.invoke(app, ["gateway", "--config", str(config_file)])diff --git a/tests/session/test_sqlite_schema.py b/tests/session/test_sqlite_schema.pyindex 2ffd0bef4..900e72b6e 100644--- a/tests/session/test_sqlite_schema.py+++ b/tests/session/test_sqlite_schema.py@@ -200,3 +200,56 @@ def test_missing_sqlite_json_support_is_rejected_before_database_changes(tmp_patstore.initialize()assert _database_snapshot(store.path) == beforeassert store.path.read_bytes() == before_bytes+++def test_v4_archive_upgrade_removes_orphans_and_preserves_existing_membership(tmp_path, monkeypatch):+ store = SqliteSessionStore(tmp_path)+ with monkeypatch.context() as patch:+ patch.setattr(sqlite_store, "_SCHEMA_MIGRATIONS", sqlite_store._SCHEMA_MIGRATIONS[:3])+ store.initialize()+ original = _session()+ store.save(original)+ store.save(Session(key="chat:empty-fork"))+ with store.transaction() as db:+ db.executemany(+ "INSERT INTO session_archives (key, archived_at) VALUES (?, ?)",+ [(key, "2026-11-01T12:00:00") for key in ("chat:extensions", "chat:empty-fork", "chat:draft")],+ )+ db.execute("INSERT INTO storage_meta (key, value) VALUES ('session_archives_imported', '1')")+ store.initialize()+ store.initialize()+ assert _database_snapshot(store.path)[0] == 4+ assert store.archived_keys() == ["chat:empty-fork", "chat:extensions"]+ assert store.archives_imported()+ assert store.load("chat:extensions") == original+ with store.transaction(write=False) as db:+ assert [row[0] for row in db.execute("SELECT archived_at FROM session_archives")] == ["2026-11-01T12:00:00"] * 2+ assert db.execute("PRAGMA foreign_key_check").fetchall() == []+ with pytest.raises(sqlite3.IntegrityError, match="FOREIGN KEY"):+ with store.transaction() as db:+ db.execute("INSERT INTO session_archives VALUES ('chat:draft', 'now')")+ assert store.archived_keys() == ["chat:empty-fork", "chat:extensions"]+++def test_archive_reference_allows_atomic_session_replacement_but_not_orphan_commit(tmp_path):+ store = SqliteSessionStore(tmp_path)+ store.initialize()+ original = _session()+ store.save(original)+ assert store.set_archived_keys([original.key]) == [original.key]+ with store.transaction(write=False) as db:+ archived_at = db.execute("SELECT archived_at FROM session_archives").fetchone()[0]+ assert store.set_archived_keys([original.key]) == [original.key]+ assert store.set_archived_keys([original.key, "chat:missing"]) == [original.key]+ with store.transaction():+ assert store.delete(original.key, preserve_archive=True)+ store.save(Session(key=original.key))+ assert store.archived_keys() == [original.key]+ with store.transaction(write=False) as db:+ assert db.execute("SELECT archived_at FROM session_archives").fetchone()[0] == archived_at+ with pytest.raises(sqlite3.IntegrityError, match="FOREIGN KEY"):+ store.delete(original.key, preserve_archive=True)+ assert store.load(original.key) is not None+ assert store.archived_keys() == [original.key]+ assert store.delete(original.key)+ assert store.archived_keys() == []diff --git a/tests/session/test_sqlite_storage.py b/tests/session/test_sqlite_storage.pyindex 645c21ce9..37a3f3c66 100644--- a/tests/session/test_sqlite_storage.py+++ b/tests/session/test_sqlite_storage.py@@ -431,3 +431,54 @@ def test_committed_version_tracks_history_and_session_replacement(tmp_path, monkmonkeypatch.setattr("nanobot.session.sqlite_store._object", unexpected_decode)assert manager.read_session_version(key) == (replacement.generation, replacement.revision)+++async def test_archive_state_survives_reopen_for_persisted_sessions_only(tmp_path):+ manager = SessionManager(tmp_path)+ state = manager.state+ try:+ await state.import_messages("websocket:active", [{"role": "user", "content": "keep history"}])+ fork = await state.fork("websocket:active", "websocket:empty", 0)+ assert fork is not None and fork.messages == []+ manager.get_or_create("websocket:draft")+ original = manager.read_session_snapshot("websocket:active")+ assert await state.import_archives(["websocket:active"]) == ["websocket:active"]+ assert await state.set_archived_keys(["websocket:active", "websocket:empty", "websocket:draft", "websocket:missing"]) == ["websocket:active", "websocket:empty"]+ assert manager.read_session_snapshot("websocket:draft") is None+ assert manager.read_session_snapshot("websocket:missing") is None+ assert manager.read_session_snapshot("websocket:empty") == fork+ assert manager.read_session_snapshot("websocket:active") == original+ finally:+ await state.aclose()++ reopened = SessionManager(tmp_path).state+ try:+ assert await reopened.archived_keys() == ["websocket:active", "websocket:empty"]+ await reopened.reset("websocket:active")+ assert await reopened.archived_keys() == ["websocket:active", "websocket:empty"]+ assert (await reopened.read("websocket:active")).messages == []+ assert await reopened.set_archived_keys(["websocket:empty"]) == ["websocket:empty"]+ # A repeated legacy import must not revive a restored session.+ assert await reopened.import_archives(["websocket:active"]) == ["websocket:empty"]+ assert await reopened.delete("websocket:empty") is True+ assert await reopened.archived_keys() == []+ finally:+ await reopened.aclose()+++async def test_archive_batch_rolls_back_on_database_failure(tmp_path):+ manager = SessionManager(tmp_path)+ state = manager.state+ try:+ await state.import_archives([])+ for key in ("websocket:first", "websocket:fail"):+ await state.import_messages(key, [{"role": "user", "content": "saved"}])+ with sqlite3.connect(manager._store.path) as db:+ db.execute("""CREATE TRIGGER fail_archive BEFORE INSERT ON session_archives+ WHEN NEW.key='websocket:fail'+ BEGIN SELECT RAISE(ABORT, 'archive failed'); END""")+ with pytest.raises(sqlite3.IntegrityError, match="archive failed"):+ await state.set_archived_keys(["websocket:first", "websocket:fail"])+ assert await state.archived_keys() == []+ finally:+ await state.aclose()diff --git a/tests/utils/test_webui_sidebar_state.py b/tests/utils/test_webui_sidebar_state.pyindex 25b4b0a10..5d4d73f48 100644--- a/tests/utils/test_webui_sidebar_state.py+++ b/tests/utils/test_webui_sidebar_state.py@@ -1,10 +1,16 @@+import asyncioimport json+import sqlite3import threadingimport timefrom concurrent.futures import ThreadPoolExecutor+import pytest+import nanobot.webui.sidebar_state as sidebar_state+from nanobot.session.manager import Session, SessionManagerfrom nanobot.webui.sidebar_state import (+ WebUISidebarState,default_webui_sidebar_state,read_webui_sidebar_state,webui_sidebar_state_path,@@ -68,7 +74,7 @@ def test_sidebar_state_normalizes_partial_payload(tmp_path, monkeypatch) -> Noneassert state["schema_version"] == 1assert state["pinned_keys"] == ["websocket:a"]- assert state["archived_keys"] == ["websocket:b"]+ assert "archived_keys" not in stateassert state["session_order"] == ["websocket:b", "websocket:a"]assert state["title_overrides"] == {"websocket:a": "Release notes"}assert state["project_name_overrides"] == {"/repo": "Core"}@@ -109,7 +115,7 @@ def test_sidebar_state_write_is_scoped_to_config_data_dir(tmp_path, monkeypatch))assert state["pinned_keys"] == ["websocket:a"]- assert state["archived_keys"] == ["websocket:b"]+ assert "archived_keys" not in stateassert state["session_order"] == ["websocket:b", "websocket:a"]assert state["title_overrides"] == {"websocket:a": "Release"}assert state["project_name_overrides"] == {"/repo": "Core"}@@ -181,3 +187,217 @@ def test_sidebar_state_serializes_concurrent_writes(monkeypatch) -> None:assert results == payloadsassert peak_writes == 1+++async def test_sidebar_archive_migration_preserves_wire_shape_and_restored_state(tmp_path, monkeypatch):+ monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)+ path = webui_sidebar_state_path()+ path.parent.mkdir(parents=True, exist_ok=True)+ path.write_text(json.dumps({+ "archived_keys": ["websocket:old", "websocket:empty", "websocket:draft"],+ "pinned_keys": ["websocket:pinned"],+ "collapsed_groups": {"archived:workspace:chats": False},+ }), encoding="utf-8")+ manager = SessionManager(tmp_path)+ manager.save(Session(key="websocket:old", messages=[{"role": "user", "content": "saved"}]))+ await manager.state.fork("websocket:old", "websocket:empty", 0)+ manager.get_or_create("websocket:draft")+ sidebar = WebUISidebarState(manager.state)+ try:+ loaded = await sidebar.read()+ assert loaded["archived_keys"] == ["websocket:empty", "websocket:old"]+ assert loaded["pinned_keys"] == ["websocket:pinned"]+ assert loaded["collapsed_groups"] == {"archived:workspace:chats": False}+ assert "archived_keys" not in json.loads(path.read_text(encoding="utf-8"))+ loaded["archived_keys"].remove("websocket:old")+ saved = await sidebar.write(loaded)+ assert saved["archived_keys"] == ["websocket:empty"]+ assert await manager.state.archived_keys() == ["websocket:empty"]+ assert {session["key"] for session in manager.list_sessions()} == {"websocket:old", "websocket:empty"}+ assert manager.read_session_snapshot("websocket:draft") is None+ finally:+ await manager.state.aclose()++ reopened = SessionManager(tmp_path)+ sidebar = WebUISidebarState(reopened.state)+ try:+ restored = await sidebar.read()+ assert restored["archived_keys"] == ["websocket:empty"]+ assert restored["pinned_keys"] == ["websocket:pinned"]+ changed_preferences = await sidebar.write({"view": {"density": "compact"}})+ assert changed_preferences["archived_keys"] == ["websocket:empty"]+ assert changed_preferences["view"]["density"] == "compact"+ assert "archived_keys" not in json.loads(path.read_text(encoding="utf-8"))+ finally:+ await reopened.state.aclose()+++async def test_archive_import_failure_keeps_json_source_for_retry(tmp_path, monkeypatch):+ monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)+ path = webui_sidebar_state_path()+ path.parent.mkdir(parents=True, exist_ok=True)+ source = json.dumps({"archived_keys": ["websocket:first", "websocket:fail"]})+ path.write_text(source, encoding="utf-8")+ manager = SessionManager(tmp_path)+ for key in ("websocket:first", "websocket:fail"):+ manager.save(Session(key=key))+ with sqlite3.connect(manager._store.path) as db:+ db.execute("""CREATE TRIGGER fail_archive BEFORE INSERT ON session_archives+ WHEN NEW.key='websocket:fail'+ BEGIN SELECT RAISE(ABORT, 'archive failed'); END""")+ try:+ with pytest.raises(sqlite3.IntegrityError, match="archive failed"):+ await WebUISidebarState(manager.state).read()+ assert path.read_text(encoding="utf-8") == source+ assert await manager.state.archives_imported() is False+ assert await manager.state.archived_keys() == []+ with sqlite3.connect(manager._store.path) as db:+ assert db.execute("SELECT key FROM session_archives").fetchall() == []+ db.execute("DROP TRIGGER fail_archive")+ assert (await WebUISidebarState(manager.state).read())["archived_keys"] == ["websocket:fail", "websocket:first"]+ finally:+ await manager.state.aclose()+++async def test_sidebar_reads_and_preferences_do_not_wait_for_unrelated_session_write(tmp_path, monkeypatch):+ monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)+ manager = SessionManager(tmp_path)+ sidebar = WebUISidebarState(manager.state)+ await manager.state.import_messages("websocket:busy", [{"role": "user", "content": "hello"}])+ await manager.state.import_messages("websocket:archived", [{"role": "user", "content": "saved"}])+ saved = await sidebar.write({"archived_keys": ["websocket:archived"]})+ held, release, entered = threading.Event(), threading.Event(), threading.Event()++ def hold_writer():+ with sqlite3.connect(manager._store.path) as db:+ db.execute("BEGIN IMMEDIATE")+ held.set()+ assert release.wait(10)++ original = manager._store.run_write++ def observe_write(operation):+ entered.set()+ return original(operation)++ holder = asyncio.create_task(asyncio.to_thread(hold_writer))+ writer = None+ try:+ assert await asyncio.to_thread(held.wait, 2)+ monkeypatch.setattr(manager._store, "run_write", observe_write)+ writer = asyncio.create_task(manager.state.update_metadata("websocket:busy", {"title": "Updated"}))+ assert await asyncio.to_thread(entered.wait, 2)+ loaded = await asyncio.wait_for(sidebar.read(), 2)+ assert loaded["archived_keys"] == ["websocket:archived"]+ changed = await asyncio.wait_for(sidebar.write({**saved, "view": {"density": "compact"}}), 2)+ assert changed["archived_keys"] == ["websocket:archived"]+ assert changed["view"]["density"] == "compact"+ assert not writer.done()+ finally:+ release.set()+ await holder+ if writer is not None:+ await writer+ await manager.state.aclose()+++async def test_archive_only_update_keeps_preferences_unchanged(tmp_path, monkeypatch):+ monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)+ manager = SessionManager(tmp_path)+ manager.save(Session(key="websocket:empty"))+ sidebar = WebUISidebarState(manager.state)+ try:+ saved = await sidebar.write({"view": {"density": "compact"}, "archived_keys": []})+ path = webui_sidebar_state_path()+ before = path.read_bytes()+ before_mtime = path.stat().st_mtime_ns+ archived = await sidebar.write({**saved, "archived_keys": ["websocket:empty"]})+ assert archived["archived_keys"] == ["websocket:empty"]+ assert await manager.state.archived_keys() == ["websocket:empty"]+ assert path.read_bytes() == before+ assert path.stat().st_mtime_ns == before_mtime+ restored = await sidebar.write({**saved, "archived_keys": []})+ assert restored["archived_keys"] == []+ assert path.stat().st_mtime_ns == before_mtime+ # A comparison failure must not prevent the existing repair-on-write path.+ for damaged in ("{broken", json.dumps({"view": {"density": []}})):+ path.write_text(damaged, encoding="utf-8")+ repaired = await sidebar.write(saved)+ assert json.loads(path.read_text(encoding="utf-8")) == {key: value for key, value in repaired.items() if key != "archived_keys"}+ finally:+ await manager.state.aclose()+++async def test_sidebar_readers_overlap_without_overtaking_queued_write(tmp_path, monkeypatch):+ monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)+ manager = SessionManager(tmp_path)+ manager.save(Session(key="websocket:new"))+ sidebar = WebUISidebarState(manager.state)+ saved = await sidebar.write({"view": {"density": "compact"}, "archived_keys": []})+ entered, release = threading.Event(), threading.Event()+ counter_lock = threading.Lock()+ count = 0+ original = sidebar_state.read_webui_sidebar_state++ def paused_read():+ nonlocal count+ with counter_lock:+ count += 1+ pause = count <= 2+ if count == 2:+ entered.set()+ if pause:+ assert release.wait(10)+ return original()++ monkeypatch.setattr(sidebar_state, "read_webui_sidebar_state", paused_read)+ readers = [asyncio.create_task(sidebar.read()) for _ in range(2)]+ pending = []+ try:+ assert await asyncio.to_thread(entered.wait, 2)+ writer = asyncio.create_task(sidebar.write({**saved, "view": {"density": "comfortable"}, "archived_keys": ["websocket:new"]}))+ later_read = asyncio.create_task(sidebar.read())+ pending.extend([writer, later_read])+ release.set()+ before = await asyncio.gather(*readers)+ assert all(snapshot["archived_keys"] == [] and snapshot["view"]["density"] == "compact" for snapshot in before)+ written, after = await asyncio.gather(writer, later_read)+ assert written["archived_keys"] == after["archived_keys"] == ["websocket:new"]+ assert written["view"]["density"] == after["view"]["density"] == "comfortable"+ finally:+ release.set()+ await asyncio.gather(*readers, *pending, return_exceptions=True)+ await manager.state.aclose()+++async def test_failed_archive_read_drains_preference_write_before_releasing_admission(tmp_path, monkeypatch):+ from nanobot.session.state import SessionOperationQueueFullError++ monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)+ manager = SessionManager(tmp_path)+ sidebar = WebUISidebarState(manager.state)+ saved = await sidebar.write({"view": {"density": "comfortable"}, "archived_keys": []})+ entered, release = threading.Event(), threading.Event()+ original = sidebar_state.write_webui_sidebar_preferences++ def paused_write(raw):+ entered.set()+ assert release.wait(10)+ return original(raw)++ async def reject_read():+ raise SessionOperationQueueFullError("session operation queue is full")++ monkeypatch.setattr(sidebar_state, "write_webui_sidebar_preferences", paused_write)+ monkeypatch.setattr(manager.state, "archived_keys", reject_read)+ write = asyncio.create_task(sidebar.write({**saved, "view": {"density": "compact"}}))+ try:+ assert await asyncio.to_thread(entered.wait, 2)+ done, _ = await asyncio.wait({write}, timeout=0.05)+ assert not done, "a failed archive read must not leave a preference write outside admission"+ finally:+ release.set()+ with pytest.raises(SessionOperationQueueFullError):+ await write+ await manager.state.aclose()+ assert json.loads(webui_sidebar_state_path().read_text(encoding="utf-8"))["view"]["density"] == "compact"diff --git a/webui/src/App.tsx b/webui/src/App.tsxindex 1fe14a5c5..d23c79f40 100644--- a/webui/src/App.tsx+++ b/webui/src/App.tsx@@ -2072,7 +2072,11 @@ function Shell({const onArchiveMany = useCallback((keys: string[], archive: boolean) => {- const selected = new Set(keys);+ const persistedKeys = new Set(sessions+ .filter((session) => session.projectLocked !== false)+ .map((session) => session.key));+ const selected = new Set(keys.filter((key) => persistedKeys.has(key)));+ if (selected.size === 0) return;void updateSidebarState((current) => {const archived = new Set(current.archived_keys);for (const key of selected) {@@ -2095,7 +2099,7 @@ function Shell({});}},- [activeKey, navigate, sidebarState.archived_keys, topicSessions, updateSidebarState],+ [activeKey, navigate, sessions, sidebarState.archived_keys, topicSessions, updateSidebarState],);const onToggleArchive = useCallback((key: string) => {@@ -2652,6 +2656,7 @@ function Shell({chatId: session.chatId,title: titleForSession(session),handle: session.handle,+ projectLocked: session.projectLocked !== false,}));return [presentation.rowKey, {tabKey: orderedTab.tabKey,diff --git a/webui/src/components/ChatList.tsx b/webui/src/components/ChatList.tsxindex 9ab1f86cc..b5f361dc3 100644--- a/webui/src/components/ChatList.tsx+++ b/webui/src/components/ChatList.tsx@@ -182,6 +182,7 @@ export interface SidebarPaneGroup {chatId: string;title: string;handle?: ChatSummary["handle"];+ projectLocked?: ChatSummary["projectLocked"];}>;}@@ -407,6 +408,18 @@ export const ChatList = memo(function ChatList({}return items;}, [paneGroups, sessions, t, titleOverrides]);+ const archivableKeys = useMemo(() => {+ const keys = new Set(sessions+ .filter((session) => session.projectLocked !== false)+ .map((session) => session.key));+ for (const group of Object.values(paneGroups)) {+ for (const pane of group.panes) {+ if (pane.projectLocked === true) keys.add(pane.key);+ else keys.delete(pane.key);+ }+ }+ return keys;+ }, [paneGroups, sessions]);const paneGroupTargets = useMemo(() => Array.from(new Map(Object.values(paneGroups).filter((group) => group.visible ?? group.panes.length > 1)@@ -699,8 +712,9 @@ export const ChatList = memo(function ChatList({if (confirmed) closeDeleteSelection();});};- const allSelectedArchived = selectedDeleteKeys.size > 0- && Array.from(selectedDeleteKeys).every((key) => archivedPanes.has(key) || archived.has(key));+ const selectedArchiveKeys = Array.from(selectedDeleteKeys).filter((key) => archivableKeys.has(key));+ const allSelectedArchived = selectedArchiveKeys.length > 0+ && selectedArchiveKeys.every((key) => archivedPanes.has(key) || archived.has(key));return (<div ref={scrollViewportRef} className="sidebar-scroll-fade sidebar-scrollbar h-full min-h-0 min-w-0 overflow-x-hidden overflow-y-auto overscroll-contain pb-2"><SidebarSelectionHighlight@@ -1116,14 +1130,16 @@ export const ChatList = memo(function ChatList({<Pencil className="h-4 w-4 shrink-0" />{t("chat.rename")}</DropdownMenuItem>- <DropdownMenuItem onSelect={() => onToggleArchive(s.key)}>- {isArchived ? (- <ArchiveRestore className="h-4 w-4 shrink-0" />- ) : (- <Archive className="h-4 w-4 shrink-0" />- )}- {isArchived ? t("chat.unarchive") : t("chat.archive")}- </DropdownMenuItem>+ {s.projectLocked !== false ? (+ <DropdownMenuItem onSelect={() => onToggleArchive(s.key)}>+ {isArchived ? (+ <ArchiveRestore className="h-4 w-4 shrink-0" />+ ) : (+ <Archive className="h-4 w-4 shrink-0" />+ )}+ {isArchived ? t("chat.unarchive") : t("chat.archive")}+ </DropdownMenuItem>+ ) : null}{paneGroup && onCreateTab ? (<DropdownMenuItem onSelect={() => onCreateTab(s.key)}><PanelsTopLeft className="h-4 w-4 shrink-0" aria-hidden />@@ -1202,14 +1218,14 @@ export const ChatList = memo(function ChatList({count: selectedDeleteKeys.size,})}</span>- {onArchiveMany ? (+ {onArchiveMany && (selectedDeleteKeys.size === 0 || selectedArchiveKeys.length > 0) ? (<HoverHint content={t(allSelectedArchived ? "chat.unarchive" : "chat.archive")}><buttontype="button"aria-label={t(allSelectedArchived ? "chat.unarchive" : "chat.archive")}disabled={selectedDeleteKeys.size === 0 || deleteConfirmationPending}onClick={() => setPendingArchive({- keys: Array.from(selectedDeleteKeys),+ keys: selectedArchiveKeys,archive: !allSelectedArchived,})}className="touch-target inline-flex h-8 w-8 shrink-0 items-center justify-center rounded-full text-foreground transition-colors media-hover:hover:bg-sidebar-accent disabled:pointer-events-none disabled:opacity-40"@@ -1589,14 +1605,16 @@ function ActivePaneRows({<Pencil className="h-4 w-4 shrink-0" />{t("chat.rename")}</DropdownMenuItem>- <DropdownMenuItem onSelect={() => onToggleArchive(pane.key)}>- {isArchived ? (- <ArchiveRestore className="h-4 w-4 shrink-0" />- ) : (- <Archive className="h-4 w-4 shrink-0" />- )}- {isArchived ? t("chat.unarchive") : t("chat.archive")}- </DropdownMenuItem>+ {pane.projectLocked === true ? (+ <DropdownMenuItem onSelect={() => onToggleArchive(pane.key)}>+ {isArchived ? (+ <ArchiveRestore className="h-4 w-4 shrink-0" />+ ) : (+ <Archive className="h-4 w-4 shrink-0" />+ )}+ {isArchived ? t("chat.unarchive") : t("chat.archive")}+ </DropdownMenuItem>+ ) : null}{onDetachPane ? (<DropdownMenuItem onSelect={() => onDetachPane(group.tabKey, pane.key)}><Unplug className="h-4 w-4 shrink-0" />diff --git a/webui/src/tests/app-layout.test.tsx b/webui/src/tests/app-layout.test.tsxindex 86ada7e3c..2d80a0c68 100644--- a/webui/src/tests/app-layout.test.tsx+++ b/webui/src/tests/app-layout.test.tsx@@ -2374,11 +2374,12 @@ describe("App layout", () => {expect(document.body.style.pointerEvents).not.toBe("none");}, 15_000);- it("archives selected topics in one sidebar update and navigates outside the full selection", async () => {+ it.each([false, true])("archives only persisted selected topics in one sidebar update (draft=%s)", async (includeDraft) => {mockSessions = ["a", "b", "c"].map((id) => ({key: `websocket:chat-${id}`, channel: "websocket", chatId: `chat-${id}`,createdAt: "2026-04-16T10:00:00Z", updatedAt: "2026-04-16T10:00:00Z",- title: `Topic ${id}`, preview: `Message ${id}`,+ title: `Topic ${id}`, preview: "",+ projectLocked: includeDraft && id === "a" ? false : undefined,}));mockFetchRoutes({"/api/webui/sidebar-state": { pinned_keys: ["websocket:chat-a", "websocket:chat-b"] },@@ -2393,17 +2394,21 @@ describe("App layout", () => {fireEvent.click(await screen.findByRole("menuitem", { name: "Select" }));fireEvent.click(within(sidebar).getByRole("button", { name: "Topic b" }));fireEvent.click(within(sidebar).getByRole("button", { name: "Archive" }));- const dialog = await screen.findByRole("alertdialog", { name: "Archive 2 topics?" });+ const dialog = await screen.findByRole("alertdialog", {+ name: includeDraft ? "Archive this topic?" : "Archive 2 topics?",+ });expect(setSidebarStateSpy).not.toHaveBeenCalled();fireEvent.click(within(dialog).getByRole("button", { name: "Archive" }));await waitFor(() => expect(setSidebarStateSpy).toHaveBeenCalledTimes(1));expect(setSidebarStateSpy).toHaveBeenCalledWith(expect.objectContaining({- archived_keys: ["websocket:chat-a", "websocket:chat-b"], pinned_keys: [],+ archived_keys: includeDraft ? ["websocket:chat-b"] : ["websocket:chat-a", "websocket:chat-b"],+ pinned_keys: includeDraft ? ["websocket:chat-a"] : [],}));- expect(window.location.hash).toBe("#/chat/websocket%3Achat-c");+ expect(window.location.hash).toBe(includeDraft ? "#/chat/websocket%3Achat-a" : "#/chat/websocket%3Achat-c");expect(within(sidebar).getByRole("button", { name: "Topic c" })).toBeInTheDocument();- expect(within(sidebar).queryByRole("button", { name: "Topic a" })).not.toBeInTheDocument();+ if (includeDraft) expect(within(sidebar).getByRole("button", { name: "Topic a" })).toBeInTheDocument();+ else expect(within(sidebar).queryByRole("button", { name: "Topic a" })).not.toBeInTheDocument();expect(within(sidebar).queryByRole("button", { name: "Topic b" })).not.toBeInTheDocument();expect(deleteChatSpy).not.toHaveBeenCalled();});diff --git a/webui/src/tests/chat-list.test.tsx b/webui/src/tests/chat-list.test.tsxindex 114f90711..999fae55e 100644--- a/webui/src/tests/chat-list.test.tsx+++ b/webui/src/tests/chat-list.test.tsx@@ -67,6 +67,75 @@ describe("ChatList", () => {expect(onTogglePin).toHaveBeenCalledWith("websocket:review");});+ it.each([false, true, undefined])("uses persistence, not preview, for topic archive actions (%s)", async (projectLocked) => {+ const onToggleArchive = vi.fn();+ render(<ChatList+ sessions={[session({ chatId: "empty", title: "Empty topic", projectLocked })]}+ activeKey={null}+ onSelect={vi.fn()}+ onRequestDelete={vi.fn()}+ onTogglePin={vi.fn()}+ onRequestRename={vi.fn()}+ onToggleArchive={onToggleArchive}+ />);+ fireEvent.contextMenu(screen.getByRole("button", { name: "Empty topic" }).closest("[data-chat-row]")!);+ await screen.findByRole("menuitem", { name: "Delete" });+ if (projectLocked === false) {+ expect(screen.queryByRole("menuitem", { name: "Archive" })).not.toBeInTheDocument();+ } else {+ fireEvent.click(screen.getByRole("menuitem", { name: "Archive" }));+ expect(onToggleArchive).toHaveBeenCalledWith("websocket:empty");+ }+ });++ it.each([+ { archivedPaneKeys: [], projectLocked: false },+ { archivedPaneKeys: ["websocket:saved"], projectLocked: false },+ { archivedPaneKeys: [], projectLocked: undefined },+ ])("archives only persisted panes in a mixed selection ($archivedPaneKeys, draft=$projectLocked)", async ({ archivedPaneKeys, projectLocked }) => {+ const onArchiveMany = vi.fn();+ const onRequestDeleteMany = vi.fn();+ render(<ChatList+ sessions={[session({ chatId: "draft", title: "Draft", projectLocked: false })]}+ paneGroups={{+ "websocket:draft": {+ tabKey: "tab", title: "Mixed group", activePaneKey: "websocket:draft",+ panes: [+ { key: "websocket:draft", chatId: "draft", title: "Draft", projectLocked },+ { key: "websocket:saved", chatId: "saved", title: "Empty fork", projectLocked: true },+ ],+ },+ }}+ archivedPaneKeys={archivedPaneKeys}+ activeKey="websocket:draft"+ onSelect={vi.fn()}+ onRequestDelete={vi.fn()}+ onRequestDeleteMany={onRequestDeleteMany}+ onTogglePin={vi.fn()}+ onRequestRename={vi.fn()}+ onToggleArchive={vi.fn()}+ onArchiveMany={onArchiveMany}+ />);+ fireEvent.pointerDown(screen.getByRole("button", { name: "Draft pane actions" }), { button: 0 });+ await screen.findByRole("menuitem", { name: "Delete" });+ expect(screen.queryByRole("menuitem", { name: "Archive" })).not.toBeInTheDocument();+ fireEvent.click(screen.getByRole("menuitem", { name: "Select" }));+ const bar = screen.getByTestId("delete-selection-bar");+ expect(within(bar).queryByRole("button", { name: "Archive" })).not.toBeInTheDocument();+ fireEvent.click(within(bar).getByRole("button", { name: "Delete" }));+ expect(onRequestDeleteMany).toHaveBeenCalledWith([+ { key: "websocket:draft", label: "Draft" },+ ], expect.any(Function));+ act(() => onRequestDeleteMany.mock.calls[0][1](false));+ fireEvent.click(screen.getByRole("button", { name: "Empty fork" }));+ const action = archivedPaneKeys.length ? "Unarchive" : "Archive";+ fireEvent.click(within(bar).getByRole("button", { name: action }));+ const dialog = screen.getByRole("alertdialog");+ expect(dialog).toHaveAccessibleName(`${action} this topic?`);+ fireEvent.click(within(dialog).getByRole("button", { name: action }));+ expect(onArchiveMany).toHaveBeenCalledWith(["websocket:saved"], !archivedPaneKeys.length);+ });+it("restores the colored handle underline and animated active track", () => {render(<ChatList@@ -827,8 +896,8 @@ describe("ChatList", () => {title: "Root topic",activePaneKey: "websocket:root",panes: [- { key: "websocket:root", chatId: "root", title: "Root topic" },- { key: "websocket:child", chatId: "child", title: "Research pane" },+ { key: "websocket:root", chatId: "root", title: "Root topic", projectLocked: true },+ { key: "websocket:child", chatId: "child", title: "Research pane", projectLocked: true },],},}}