Skip to content

Your lightweight open-source personal agent.

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.py
index 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.asyncio
diff --git a/nanobot/channels/websocket/tests/test_websocket_http_routes.py b/nanobot/channels/websocket/tests/test_websocket_http_routes.py
index 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 == 200
body = 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_task
diff --git a/nanobot/cli/gateway_runtime.py b/nanobot/cli/gateway_runtime.py
index 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_templates
from nanobot.utils.token_encoding import warmup_token_encoding
from nanobot.webui.build import BuildMode
from 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_archives
if 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 = None
if 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.py
index 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 deleted
def list_sessions(self) -> list[SessionInfo]:
with self.transaction(write=False) as db:
diff --git a/nanobot/session/state.py b/nanobot/session/state.py
index 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 = False
self._close_task: asyncio.Task[None] | None = None
self._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 session
diff --git a/nanobot/webui/inbound_commands.py b/nanobot/webui/inbound_commands.py
index 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_state
from nanobot.webui.temporary_chats import TemporaryChatError
from nanobot.webui.transcription_ws import webui_transcription_event
@@ -405,10 +404,7 @@ class WebUICommandRouter:
)
return
try:
- 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.py
index 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 asyncio
import json
import math
import os
import threading
import time
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
from pathlib import Path
-from typing import Any, cast
+from typing import TYPE_CHECKING, Any, cast
from loguru import logger
from nanobot.config.paths import get_webui_dir
+from nanobot.utils.cancellation import shield_and_drain
+
+if TYPE_CHECKING:
+ from nanobot.session.state import SessionState
WEBUI_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.py
index 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 = config
self.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_path
self.runtime_model_name = runtime_model_name
self.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 None
def _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.py
index 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.py
index 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_pat
store.initialize()
assert _database_snapshot(store.path) == before
assert 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.py
index 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, monk
monkeypatch.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.py
index 25b4b0a10..5d4d73f48 100644
--- a/tests/utils/test_webui_sidebar_state.py
+++ b/tests/utils/test_webui_sidebar_state.py
@@ -1,10 +1,16 @@
+import asyncio
import json
+import sqlite3
import threading
import time
from concurrent.futures import ThreadPoolExecutor
+import pytest
+
import nanobot.webui.sidebar_state as sidebar_state
+from nanobot.session.manager import Session, SessionManager
from 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) -> None
assert state["schema_version"] == 1
assert state["pinned_keys"] == ["websocket:a"]
- assert state["archived_keys"] == ["websocket:b"]
+ assert "archived_keys" not in state
assert 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 state
assert 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 == payloads
assert 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.tsx
index 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.tsx
index 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")}>
<button
type="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.tsx
index 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.tsx
index 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 },
],
},
}}