free-claude-code 6.4.1__tar.gz → 6.4.2__tar.gz

{free_claude_code-6.4.1 → free_claude_code-6.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: free-claude-code
-Version: 6.4.1
+Version: 6.4.2
 Summary: Local proxy connecting coding agents to OpenAI-compatible AI providers
 License-Expression: AGPL-3.0-only
 License-File: LICENSE

{free_claude_code-6.4.1 → free_claude_code-6.4.2}/e2e/code_support.py

@@ -6,6 +6,7 @@ from unittest.mock import patch
 
 from free_claude_code.application.code_sessions import CodeService
 from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStore
+from free_claude_code.runtime.sqlite_database import SQLiteDatabase
 from tests.code_sessions_support import FakeHarness
 
 
@@ -13,8 +14,9 @@ class CodeControl:
     def __init__(self, directory):
         self.harness = FakeHarness()
         self.folder_picker = FolderPickerControl()
+        self.database = SQLiteDatabase(directory / "fcc.db", directory / "code.lock")
         self.service = CodeService(
-            SQLiteCodeStore(directory / "code.db", directory / "code.lock"),
+            SQLiteCodeStore(self.database),
             self.harness,
         )
         self.loop: asyncio.AbstractEventLoop | None = None

{free_claude_code-6.4.1 → free_claude_code-6.4.2}/e2e/conftest.py

@@ -268,6 +268,7 @@ def admin_base_url(
         configuration=ConfigurationService(ManagedConfigStore()),
         transcriber=None,
         code_service=code_control.service,
+        database=code_control.database,
     )
     monkeypatch.setattr(
         NativeFolderPicker,

{free_claude_code-6.4.1 → free_claude_code-6.4.2}/e2e/test_claude_desktop_integration.py

@@ -38,19 +38,26 @@ def test_real_disconnect_failure_keeps_retry_after_reload(
                 ),
             )
         elif status_failure == "startup":
+            marker = tmp_path / ".fcc/claude-desktop-disconnect.json"
+            failed = {"state": "failed", "message": "Startup check failed"}
 
             def failed_update(route):
                 result = route.fetch()
                 body = result.json()
-                if body["disconnect_pending"]:
+                if marker.exists():
                     body["connected"] = None
-                    body["update"] = {
-                        "state": "failed",
-                        "message": "Startup check failed",
-                    }
+                    body["update"] = failed
+                route.fulfill(response=result, json=body)
+
+            def failed_startup(route):
+                result = route.fetch()
+                body = result.json()
+                if marker.exists():
+                    body["startup"]["integrations"]["claude-desktop"] = failed
                 route.fulfill(response=result, json=body)
 
             page.route(endpoint, failed_update)
+            page.route("**/admin/api/status", failed_startup)
         dialog.get_by_role("button", name="Disconnect", exact=True).click()
         expect(
             dialog.get_by_role(

{free_claude_code-6.4.1 → free_claude_code-6.4.2}/e2e/test_connected_accounts.py

@@ -66,6 +66,14 @@ class _Accounts:
             page.wait_for_timeout(10)
         return self.pending_status.pop(0)
 
+    def take_pending_login(self, page: Page) -> Route:
+        deadline = time.monotonic() + 5
+        while not self.pending_login:
+            if time.monotonic() >= deadline:
+                pytest.fail("Account login request did not reach the route handler")
+            page.wait_for_timeout(10)
+        return self.pending_login.pop(0)
+
     def config(self, route: Route) -> None:
         response = route.fetch()
         config = response.json()
@@ -247,9 +255,10 @@ def test_openai_connect_uses_browser_login(
     try:
         assert popup.url == "about:blank"
         assert popup.evaluate("window.opener === null") is True
+        login = accounts.take_pending_login(page)
         assert accounts.login_requests == [("openai", "browser")]
-        assert len(accounts.pending_login) == 1
-        accounts.pending_login.pop().fulfill(json=accounts.statuses["openai"])
+        assert not accounts.pending_login
+        login.fulfill(json=accounts.statuses["openai"])
         popup.wait_for_url(f"{admin_base_url}/account-test-sign-in")
     finally:
         popup.close()

free_claude_code-6.4.2/e2e/test_messaging_storage_recovery.py

@@ -0,0 +1,27 @@
+import pytest
+from playwright.sync_api import expect
+
+
+@pytest.fixture
+def admin_client_files(tmp_path):
+    source = tmp_path / ".fcc/agent_workspace/sessions.json"
+    source.parent.mkdir(parents=True)
+    source.write_text('{"conversation":')
+    return source
+
+
+def test_damaged_legacy_history_warns_without_blocking_settings(
+    page, admin_base_url, admin_client_files
+):
+    page.goto(f"{admin_base_url}/admin")
+    page.get_by_role("button", name="Messaging", exact=True).click()
+    notice = page.locator("#startupMessage")
+    expect(notice).to_be_visible()
+    expect(notice).to_contain_text("Messaging can still be used")
+    expect(page.locator("#field-TELEGRAM_BOT_TOKEN")).to_be_enabled()
+    assert admin_client_files.read_text() == '{"conversation":'
+    # A preserved source is not a second writer, and the server stays usable.
+    response = page.request.get(f"{admin_base_url}/health")
+    assert response.ok
+    page.get_by_role("button", name="Providers", exact=True).click()
+    expect(notice).to_be_hidden()

{free_claude_code-6.4.1 → free_claude_code-6.4.2}/smoke/capabilities.py

@@ -491,7 +491,7 @@ CAPABILITY_CONTRACTS: tuple[CapabilityContract, ...] = (
         "persistence",
         "restart_restore",
         "restart_restore",
-        "free_claude_code.messaging.session.SessionStore",
+        "free_claude_code.runtime.messaging_sqlite.SQLiteMessagingStore",
         "stored tree JSON",
         "restored scoped reply lookup",
         "stale pending work marked lost",
@@ -501,11 +501,11 @@ CAPABILITY_CONTRACTS: tuple[CapabilityContract, ...] = (
         "persistence",
         "session_store",
         "session_persistence",
-        "free_claude_code.messaging.session.SessionStore",
+        "free_claude_code.runtime.messaging_sqlite.SQLiteMessagingStore",
         "scoped tree data and message log",
-        "JSON persistence compatible with existing files",
-        "best-effort flush error logging",
-        ("tests/messaging/test_session_store_edge_cases.py",),
+        "transactional SQLite persistence with one-time legacy JSON import",
+        "storage failures propagate to the owning messaging operation",
+        ("tests/runtime/test_messaging_sqlite.py",),
     ),
     CapabilityContract(
         "voice",

{free_claude_code-6.4.1 → free_claude_code-6.4.2}/smoke/features.py

@@ -638,8 +638,8 @@ FEATURE_INVENTORY: tuple[FeatureCoverage, ...] = (
     ),
     FeatureCoverage(
         "session_persistence",
-        "Session JSON preserves scoped trees and message logs",
-        ("tests/messaging/test_session_store_edge_cases.py",),
+        "SQLite persistence preserves scoped trees and message logs",
+        ("tests/runtime/test_messaging_sqlite.py",),
         (),
         ("test_restart_restore_and_session_persistence_e2e",),
         ("messaging",),

{free_claude_code-6.4.1 → free_claude_code-6.4.2}/smoke/lib/e2e.py

@@ -27,9 +27,10 @@ from free_claude_code.core.anthropic.stream_contracts import (
 )
 from free_claude_code.harnesses.claude import build_claude_proxy_env
 from free_claude_code.messaging.models import IncomingMessage, MessageScope
-from free_claude_code.messaging.session import SessionStore
 from free_claude_code.messaging.voice import VoiceCancellationResult
 from free_claude_code.messaging.workflow import MessagingWorkflow
+from free_claude_code.runtime.messaging_sqlite import SQLiteMessagingStore
+from free_claude_code.runtime.sqlite_database import SQLiteDatabase
 from smoke.lib.child_process import run_captured_text
 from smoke.lib.config import ProviderModel, SmokeConfig, auth_headers
 from smoke.lib.http import conversation_headers
@@ -568,15 +569,18 @@ class FakePlatformDriver:
     event_batches: list[list[dict[str, Any]]] | None = None
     platform: FakePlatform = field(init=False)
     cli_manager: FakeCLIManager = field(init=False)
-    session_store: SessionStore = field(init=False)
+    session_store: SQLiteMessagingStore = field(init=False)
     workflow: MessagingWorkflow = field(init=False)
+    database: SQLiteDatabase = field(init=False)
 
     def __post_init__(self) -> None:
         self.platform = FakePlatform(self.platform_name)
         self.cli_manager = FakeCLIManager(self.event_batches)
-        self.session_store = SessionStore(
-            storage_path=str(self.tmp_path / f"{self.platform_name}-sessions.json")
+        self.database = SQLiteDatabase(
+            self.tmp_path / f"{self.platform_name}-fcc.db",
+            self.tmp_path / f"{self.platform_name}-fcc.lock",
         )
+        self.session_store = SQLiteMessagingStore(self.database)
         self.workflow = MessagingWorkflow(
             self.platform,
             self.cli_manager,
@@ -586,6 +590,14 @@ class FakePlatformDriver:
         )
         self.platform.on_message(self.workflow.handle_message)
 
+    async def start(self) -> None:
+        await self.database.start()
+        await self.workflow.restore()
+
+    async def close(self) -> None:
+        await self.workflow.close()
+        await self.database.close()
+
     async def send(
         self,
         text: str,
@@ -628,7 +640,7 @@ class FakePlatformDriver:
         while time.monotonic() < deadline:
             pending = [task for task in self.platform._tasks if not task.done()]
             if not pending and await self._all_tree_nodes_terminal():
-                self.session_store.flush_pending_save()
+                await self.workflow.tree_queue.wait_idle()
                 return
             await asyncio.sleep(0.02)
         raise AssertionError("fake platform did not become idle")

{free_claude_code-6.4.1 → free_claude_code-6.4.2}/smoke/product/test_messaging_product_live.py

@@ -1,7 +1,7 @@
 import asyncio
-import json
 
 import pytest
+import pytest_asyncio
 
 from free_claude_code.messaging.models import MessageScope
 from free_claude_code.messaging.platforms.ports import MessagingStartupNotice
@@ -13,8 +13,10 @@ pytestmark = [pytest.mark.live, pytest.mark.smoke_target("messaging")]
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("platform_name", ["discord", "telegram"])
-async def test_messaging_fake_full_flow_e2e(platform_name: str, tmp_path) -> None:
-    driver = FakePlatformDriver(platform_name, tmp_path)
+async def test_messaging_fake_full_flow_e2e(
+    driver_factory, platform_name: str, tmp_path
+) -> None:
+    driver = await driver_factory(platform_name, tmp_path)
 
     incoming = await driver.send("Please inspect README.", message_id="root_1")
 
@@ -33,7 +35,9 @@ async def test_messaging_fake_full_flow_e2e(platform_name: str, tmp_path) -> Non
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("platform_name", ["discord", "telegram"])
-async def test_messaging_subagent_control_e2e(platform_name: str, tmp_path) -> None:
+async def test_messaging_subagent_control_e2e(
+    driver_factory, platform_name: str, tmp_path
+) -> None:
     task_events = [
         {"type": "session_info", "session_id": "sess_task"},
         {
@@ -53,7 +57,7 @@ async def test_messaging_subagent_control_e2e(platform_name: str, tmp_path) -> N
         },
         {"type": "exit", "code": 0, "stderr": None},
     ]
-    driver = FakePlatformDriver(platform_name, tmp_path, event_batches=[task_events])
+    driver = await driver_factory(platform_name, tmp_path, event_batches=[task_events])
 
     await driver.send("Delegate this safely.", message_id="root_task")
 
@@ -65,9 +69,9 @@ async def test_messaging_subagent_control_e2e(platform_name: str, tmp_path) -> N
 @pytest.mark.asyncio
 @pytest.mark.parametrize("platform_name", ["discord", "telegram"])
 async def test_messaging_commands_stop_clear_stats_e2e(
-    platform_name: str, tmp_path
+    driver_factory, platform_name: str, tmp_path
 ) -> None:
-    driver = FakePlatformDriver(platform_name, tmp_path)
+    driver = await driver_factory(platform_name, tmp_path)
     root = await driver.send("start work", message_id="root_1")
     root_status_id = driver.platform.sent[-1]["message_id"]
 
@@ -90,16 +94,17 @@ async def test_messaging_commands_stop_clear_stats_e2e(
         "clear_1",
         "clear_all",
     } <= deleted
-    assert driver.session_store.load_conversation_snapshot().trees == {}
+    assert (await driver.session_store.load_conversation_snapshot()).trees == {}
 
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("platform_name", ["discord", "telegram"])
 async def test_reply_clear_uses_literal_platform_subtree_e2e(
+    driver_factory,
     platform_name: str,
     tmp_path,
 ) -> None:
-    driver = FakePlatformDriver(platform_name, tmp_path)
+    driver = await driver_factory(platform_name, tmp_path)
     root = await driver.send("root", message_id="root")
     root_status = driver.platform.sent[-1]["message_id"]
     sibling = await driver.send(
@@ -158,8 +163,10 @@ async def test_reply_clear_uses_literal_platform_subtree_e2e(
 
 
 @pytest.mark.asyncio
-async def test_messaging_startup_notice_is_clearable_e2e(tmp_path) -> None:
-    first_driver = FakePlatformDriver("telegram", tmp_path)
+async def test_messaging_startup_notice_is_clearable_e2e(
+    driver_factory, tmp_path
+) -> None:
+    first_driver = await driver_factory("telegram", tmp_path)
     scope = MessageScope(platform="telegram", chat_id="chat_1")
 
     await first_driver.workflow.publish_startup_notice(
@@ -169,9 +176,9 @@ async def test_messaging_startup_notice_is_clearable_e2e(tmp_path) -> None:
         )
     )
     first_startup_id = first_driver.platform.sent[-1]["message_id"]
-    first_driver.session_store.flush_pending_save()
 
-    driver = FakePlatformDriver("telegram", tmp_path)
+    await first_driver.close()
+    driver = await driver_factory("telegram", tmp_path)
     await driver.platform.send_message("untracked", "advance fake message ID")
     await driver.workflow.publish_startup_notice(
         MessagingStartupNotice(
@@ -185,7 +192,7 @@ async def test_messaging_startup_notice_is_clearable_e2e(tmp_path) -> None:
         "🚀 *Claude Code Proxy is online\\!* \\(Bot API\\)"
     )
     assert second_startup["parse_mode"] == "MarkdownV2"
-    assert driver.session_store.get_tracked_message_ids_for_chat(
+    assert await driver.session_store.get_tracked_message_ids_for_chat(
         scope.platform, scope.chat_id
     ) == [first_startup_id, second_startup_id]
 
@@ -194,7 +201,7 @@ async def test_messaging_startup_notice_is_clearable_e2e(tmp_path) -> None:
     deleted = {entry["message_id"] for entry in driver.platform.deletes}
     assert {first_startup_id, second_startup_id, "clear_startup"} <= deleted
     assert (
-        driver.session_store.get_tracked_message_ids_for_chat(
+        await driver.session_store.get_tracked_message_ids_for_chat(
             scope.platform, scope.chat_id
         )
         == []
@@ -204,11 +211,12 @@ async def test_messaging_startup_notice_is_clearable_e2e(tmp_path) -> None:
 @pytest.mark.asyncio
 @pytest.mark.parametrize("platform_name", ["discord", "telegram"])
 async def test_messaging_active_stop_uses_status_only_e2e(
+    driver_factory,
     platform_name: str,
     tmp_path,
     monkeypatch,
 ) -> None:
-    driver = FakePlatformDriver(platform_name, tmp_path)
+    driver = await driver_factory(platform_name, tmp_path)
     started = asyncio.Event()
 
     class GatedActiveSession(FakeCLISession):
@@ -272,9 +280,9 @@ async def test_messaging_active_stop_uses_status_only_e2e(
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("platform_name", ["discord", "telegram"])
-async def test_tree_threading_e2e(platform_name: str, tmp_path) -> None:
+async def test_tree_threading_e2e(driver_factory, platform_name: str, tmp_path) -> None:
     batches = [default_cli_events("sess_root"), default_cli_events("sess_branch")]
-    driver = FakePlatformDriver(platform_name, tmp_path, event_batches=batches)
+    driver = await driver_factory(platform_name, tmp_path, event_batches=batches)
 
     root = await driver.send("root prompt", message_id="root_1")
     branch = await driver.send(
@@ -294,11 +302,12 @@ async def test_tree_threading_e2e(platform_name: str, tmp_path) -> None:
 @pytest.mark.asyncio
 @pytest.mark.parametrize("platform_name", ["discord", "telegram"])
 async def test_messaging_queued_scoped_cancel_e2e(
+    driver_factory,
     platform_name: str,
     tmp_path,
     monkeypatch,
 ) -> None:
-    driver = FakePlatformDriver(platform_name, tmp_path)
+    driver = await driver_factory(platform_name, tmp_path)
     root_started = asyncio.Event()
     release_root = asyncio.Event()
 
@@ -392,27 +401,29 @@ async def test_messaging_queued_scoped_cancel_e2e(
         edit["message_id"] == cancelled_status_id and "Stopped" in edit["text"]
         for edit in driver.platform.edits
     )
-    driver.session_store.flush_pending_save()
-    persisted = driver.session_store.load_conversation_snapshot()
+    persisted = await driver.session_store.load_conversation_snapshot()
     root_identity = TreeIdentity(scope=root.scope, root_id=root.message_id)
     assert persisted.trees[root_identity].nodes["survivor"]["state"] == "completed"
 
 
 @pytest.mark.asyncio
-async def test_restart_restore_and_session_persistence_e2e(tmp_path) -> None:
-    first = FakePlatformDriver("telegram", tmp_path)
+async def test_restart_restore_and_session_persistence_e2e(
+    driver_factory, tmp_path
+) -> None:
+    first = await driver_factory("telegram", tmp_path)
     root = await first.send("persist me", message_id="root_1")
-    first.session_store.flush_pending_save()
 
-    session_file = tmp_path / "telegram-sessions.json"
-    payload = json.loads(session_file.read_text(encoding="utf-8"))
-    assert payload["conversation"]["trees"]
-    assert payload["managed_messages"]
+    saved_before = await first.session_store.load_conversation_snapshot()
+    assert saved_before.trees
+    assert await first.session_store.get_tracked_message_ids_for_chat(
+        "telegram", "chat_1"
+    )
+    await first.close()
 
-    restored = FakePlatformDriver("telegram", tmp_path)
+    restored = await driver_factory("telegram", tmp_path)
     restored.platform.continue_message_sequence_after(first.platform)
-    restored.workflow.restore()
-    saved = restored.session_store.load_conversation_snapshot()
+    await restored.workflow.restore()
+    saved = await restored.session_store.load_conversation_snapshot()
     assert saved.trees
     identity = TreeIdentity(scope=root.scope, root_id=root.message_id)
     assert saved.get_tree(identity) is not None
@@ -436,10 +447,11 @@ async def test_restart_restore_and_session_persistence_e2e(tmp_path) -> None:
 @pytest.mark.asyncio
 @pytest.mark.parametrize("platform_name", ["discord", "telegram"])
 async def test_same_message_ids_are_isolated_by_chat_e2e(
+    driver_factory,
     platform_name: str,
     tmp_path,
 ) -> None:
-    driver = FakePlatformDriver(platform_name, tmp_path)
+    driver = await driver_factory(platform_name, tmp_path)
     first = await driver.send("first chat", chat_id="chat_a", message_id="42")
     second = await driver.send("second chat", chat_id="chat_b", message_id="42")
 
@@ -462,8 +474,10 @@ async def test_same_message_ids_are_isolated_by_chat_e2e(
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("platform_name", ["discord", "telegram"])
-async def test_voice_platform_fake_e2e(platform_name: str, tmp_path) -> None:
-    driver = FakePlatformDriver(platform_name, tmp_path)
+async def test_voice_platform_fake_e2e(
+    driver_factory, platform_name: str, tmp_path
+) -> None:
+    driver = await driver_factory(platform_name, tmp_path)
     driver.platform.seed_pending_voice("chat_1", "voice_msg_1", "voice_status_1")
 
     await driver.send("/clear", message_id="clear_voice", reply_to="voice_msg_1")
@@ -482,3 +496,21 @@ async def test_voice_platform_fake_e2e(platform_name: str, tmp_path) -> None:
         edit["message_id"] == "voice_status_2" and "Stopped" in edit["text"]
         for edit in driver.platform.edits
     )
+
+
+@pytest_asyncio.fixture
+async def driver_factory():
+    drivers = []
+
+    async def create(*args, **kwargs):
+        driver = FakePlatformDriver(*args, **kwargs)
+        await driver.start()
+        drivers.append(driver)
+        return driver
+
+    try:
+        yield create
+    finally:
+        for driver in reversed(drivers):
+            if driver.database._started:
+                await driver.close()

{free_claude_code-6.4.1 → free_claude_code-6.4.2}/src/free_claude_code/api/admin_static/admin.js

@@ -123,12 +123,12 @@ function renderStartup() {
   const message = byId("startupMessage");
   if (message) {
     const messaging = startup?.messaging;
-    const visible = state.activeView === "messaging" && ["starting", "failed"].includes(messaging?.state);
+    const visible = state.activeView === "messaging" && (["starting", "failed"].includes(messaging?.state) || Boolean(messaging?.warning));
     message.hidden = !visible;
     message.classList.toggle("startup-spinner", visible && messaging.state === "starting");
     message.classList.toggle("error", messaging?.state === "failed");
-    message.textContent = messaging?.state === "failed" ? messaging.message || "Messaging could not start." : "";
-    message.setAttribute("aria-label", "Messaging is starting");
+    message.textContent = messaging?.state === "failed" ? messaging.message || "Messaging could not start." : messaging?.warning || "";
+    message.setAttribute("aria-label", messaging?.state === "starting" ? "Messaging is starting" : "Messaging status");
   }
   if (!startup) return;
   document.querySelectorAll("[data-startup-provider]").forEach((button) => {

{free_claude_code-6.4.1 → free_claude_code-6.4.2}/src/free_claude_code/messaging/command_context.py

@@ -76,7 +76,7 @@ class MessagingCommandContext(Protocol):
         """Clear one chat and return every tracked platform message ID."""
         ...
 
-    def forget_tracked_message_ids(
+    async def forget_tracked_message_ids(
         self,
         platform: str,
         chat_id: str,
@@ -85,7 +85,7 @@ class MessagingCommandContext(Protocol):
         """Forget platform message IDs removed from the managed conversation."""
         ...
 
-    def record_outgoing_message(
+    async def record_outgoing_message(
         self,
         platform: str,
         chat_id: str,

{free_claude_code-6.4.1 → free_claude_code-6.4.2}/src/free_claude_code/messaging/commands.py

@@ -21,7 +21,7 @@ async def _send_stop_feedback(
         fire_and_forget=False,
         message_thread_id=incoming.message_thread_id,
     )
-    handler.record_outgoing_message(
+    await handler.record_outgoing_message(
         incoming.platform, incoming.chat_id, msg_id, "command"
     )
 
@@ -85,7 +85,7 @@ async def handle_stats_command(
         fire_and_forget=False,
         message_thread_id=incoming.message_thread_id,
     )
-    handler.record_outgoing_message(
+    await handler.record_outgoing_message(
         incoming.platform, incoming.chat_id, msg_id, "command"
     )
 
@@ -157,7 +157,7 @@ async def handle_clear_command(
                 fire_and_forget=False,
                 message_thread_id=incoming.message_thread_id,
             )
-            handler.record_outgoing_message(
+            await handler.record_outgoing_message(
                 incoming.platform, incoming.chat_id, msg_id, "command"
             )
             return
@@ -166,7 +166,7 @@ async def handle_clear_command(
         if incoming.message_id is not None:
             delete_message_ids.add(str(incoming.message_id))
         await _delete_message_ids(handler, incoming.chat_id, delete_message_ids)
-        handler.forget_tracked_message_ids(
+        await handler.forget_tracked_message_ids(
             incoming.platform,
             incoming.chat_id,
             delete_message_ids,

{free_claude_code-6.4.1 → free_claude_code-6.4.2}/src/free_claude_code/messaging/node_runner.py

@@ -16,9 +16,13 @@ from .managed_protocols import ManagedClaudeSessionManagerProtocol
 from .node_event_pipeline import handle_session_info_event, process_parsed_cli_event
 from .platforms.ports import OutboundMessenger
 from .safe_diagnostics import format_exception_for_log
-from .session import SessionStore
 from .transcript import RenderCtx, TranscriptBuffer
-from .trees import CancellationReason, NodeClaim, TreeQueueManager, TreeSnapshot
+from .trees import (
+    CancellationReason,
+    MessagingStorageError,
+    NodeClaim,
+    TreeQueueManager,
+)
 from .ui_updates import ThrottledTranscriptEditor
 
 
@@ -31,7 +35,6 @@ class MessagingNodeRunner:
         platform_name: str,
         outbound: OutboundMessenger,
         cli_manager: ManagedClaudeSessionManagerProtocol,
-        session_store: SessionStore,
         get_tree_queue: Callable[[], TreeQueueManager],
         format_status: Callable[[str, str, str | None], str],
         get_parse_mode: Callable[[], str | None],
@@ -45,7 +48,6 @@ class MessagingNodeRunner:
         self.platform_name = platform_name
         self.outbound = outbound
         self.cli_manager = cli_manager
-        self.session_store = session_store
         self._get_tree_queue = get_tree_queue
         self._format_status = format_status
         self._get_parse_mode = get_parse_mode
@@ -66,23 +68,15 @@ class MessagingNodeRunner:
         )
         return transcript, self._get_render_ctx()
 
-    def _save_snapshot(self, snapshot: TreeSnapshot | None) -> None:
-        """Persist a snapshot returned by the active aggregate manager."""
-        if snapshot is None:
-            return
-        self.session_store.save_tree_snapshot(snapshot)
-
     async def _record_session(self, claim: NodeClaim, session_id: str) -> None:
-        snapshot = await self._get_tree_queue().record_session(claim, session_id)
-        self._save_snapshot(snapshot)
+        await self._get_tree_queue().record_session(claim, session_id)
 
     async def _complete_claim(
         self,
         claim: NodeClaim,
         session_id: str | None,
     ) -> None:
-        snapshot = await self._get_tree_queue().complete_claim(claim, session_id)
-        self._save_snapshot(snapshot)
+        await self._get_tree_queue().complete_claim(claim, session_id)
 
     async def _fail_claim(
         self,
@@ -95,7 +89,6 @@ class MessagingNodeRunner:
             claim,
             propagate=propagate,
         )
-        self._save_snapshot(result.snapshot)
         if child_status_text is None:
             return
         for child in result.affected:
@@ -358,6 +351,9 @@ class MessagingNodeRunner:
                 claim,
                 propagate=False,
             )
+        except MessagingStorageError:
+            # The processor owns interruption reporting, including queued turns.
+            raise
         except Exception as e:
             trace_event(
                 stage="claude_cli",

{free_claude_code-6.4.1 → free_claude_code-6.4.2}/src/free_claude_code/messaging/trees/__init__.py

@@ -1,8 +1,10 @@
 """Internal messaging tree package facade."""
 
+from .graph import normalize_tree_snapshot
 from .identity import TreeIdentity
 from .manager import TreeQueueManager
 from .node import MessageReferenceKind, MessageState
+from .ports import MessagingStorageError, MessagingStore
 from .snapshot import ConversationSnapshot, TreeSnapshot
 from .transitions import (
     AdmissionRejection,
@@ -29,6 +31,8 @@ __all__ = [
     "MessageReferenceKind",
     "MessageState",
     "MessageSubtreeRemovalResult",
+    "MessagingStorageError",
+    "MessagingStore",
     "NodeClaim",
     "NodeUiTarget",
     "NodeView",
@@ -38,4 +42,5 @@ __all__ = [
     "TreeIdentity",
     "TreeQueueManager",
     "TreeSnapshot",
+    "normalize_tree_snapshot",
 ]

{free_claude_code-6.4.1 → free_claude_code-6.4.2}/src/free_claude_code/messaging/trees/graph.py

@@ -248,3 +248,17 @@ class MessageTreeGraph:
         if set(graph.get_descendants(graph.root_id)) != set(graph._nodes):
             raise ValueError("Tree snapshot contains a disconnected branch")
         return graph
+
+
+def normalize_tree_snapshot(snapshot: TreeSnapshot) -> TreeSnapshot:
+    """Validate domain links and return detached records in parent-first order."""
+    graph = MessageTreeGraph.from_snapshot(snapshot)
+    normalized = graph.snapshot()
+    return TreeSnapshot(
+        normalized.scope,
+        normalized.root_id,
+        {
+            node_id: normalized.nodes[node_id]
+            for node_id in graph.get_descendants(graph.root_id)
+        },
+    )