ccgram 3.3.2__tar.gz → 3.3.3__tar.gz

{ccgram-3.3.2 → ccgram-3.3.3}/CHANGELOG.md

@@ -4,11 +4,20 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+## [3.3.3] - 2026-05-23
+
+### Changed
+- Cut session_map.json reads + collapse repetitive poll-loop logs
+
 ## [3.3.2] - 2026-05-23
 
 ### Changed
 - Unify tool-call formatting + ephemeral bubble UX fixes ([#100](https://github.com/alexei-led/ccgram/pull/100))
 
+
+### Documentation
+- Update CHANGELOG.md for v3.3.2
+
 ## [3.3.1] - 2026-05-22
 
 ### Added

{ccgram-3.3.2 → ccgram-3.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ccgram
-Version: 3.3.2
+Version: 3.3.3
 Summary: CCGram — manage AI coding agents from Telegram via tmux
 Project-URL: Homepage, https://github.com/alexei-led/ccgram
 Project-URL: Repository, https://github.com/alexei-led/ccgram

{ccgram-3.3.2 → ccgram-3.3.3}/src/ccgram/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.3.2'
-__version_tuple__ = version_tuple = (3, 3, 2)
+__version__ = version = '3.3.3'
+__version_tuple__ = version_tuple = (3, 3, 3)
 
 __commit_id__ = commit_id = None

{ccgram-3.3.2 → ccgram-3.3.3}/src/ccgram/mailbox.py

@@ -377,7 +377,8 @@ class Mailbox:
             ]
         )
         removed = sum(self._sweep_dir(d) for d in dirs if d.is_dir())
-        logger.debug("Sweep completed", removed=removed, window_id=window_id)
+        if removed:
+            logger.debug("Sweep completed", removed=removed, window_id=window_id)
         return removed
 
     def _sweep_dir(self, inbox_dir: Path) -> int:

{ccgram-3.3.2 → ccgram-3.3.3}/src/ccgram/session_map.py

@@ -42,6 +42,12 @@ logger = structlog.get_logger()
 _LEGACY_SESSION_PREFIX = "ccbot:"
 _DEFAULT_PRIMARY_SESSION_GRACE_SEC = 60.0
 
+# Per-window memo of the last incoming session_id we logged a "preserve" for.
+# Decision is stable across poll cycles (steady state: same nested sid arrives
+# every ~1s); logging the conclusion every cycle is pure noise.  Log only on
+# transition — when the incoming sid we're rejecting changes.
+_preserve_log_memo: dict[str, str] = {}
+
 
 def _primary_session_grace_sec() -> float:
     raw = os.getenv("CCGRAM_NESTED_SESSION_GRACE_SEC")
@@ -58,6 +64,24 @@ def _primary_session_grace_sec() -> float:
         return _DEFAULT_PRIMARY_SESSION_GRACE_SEC
 
 
+async def read_session_map_raw() -> dict[str, Any] | None:
+    """Read and parse session_map.json once.
+
+    Returns the parsed dict, ``{}`` if the file does not exist, or ``None``
+    if read/parse failed.  Caller passes the result to both
+    ``SessionMapSync.load_session_map`` and ``parse_session_map`` to avoid
+    re-reading the file twice per poll cycle.
+    """
+    if not config.session_map_file.exists():
+        return {}
+    try:
+        async with aiofiles.open(config.session_map_file, "r") as f:
+            content = await f.read()
+        return cast(dict[str, Any], json.loads(content))
+    except json.JSONDecodeError, OSError:
+        return None
+
+
 def _transcript_mtime(transcript_path: str) -> float | None:
     if not transcript_path:
         return None
@@ -105,12 +129,14 @@ def _prefer_existing_primary(
     if not existing_is_fresh and not existing_is_newer:
         return None
 
-    logger.debug(
-        "Preserving primary session for window_id %s: existing %s, incoming %s treated as nested",
-        window_id,
-        state.session_id,
-        incoming_sid,
-    )
+    if _preserve_log_memo.get(window_id) != incoming_sid:
+        _preserve_log_memo[window_id] = incoming_sid
+        logger.debug(
+            "Preserving primary session for window_id %s: existing %s, incoming %s treated as nested",
+            window_id,
+            state.session_id,
+            incoming_sid,
+        )
     return {
         "session_id": state.session_id,
         "cwd": state.cwd,
@@ -195,7 +221,7 @@ class SessionMapSync:
     # Public: async read/sync methods
     # ------------------------------------------------------------------
 
-    async def load_session_map(self) -> None:
+    async def load_session_map(self, raw: dict[str, Any] | None = None) -> None:
         """Read session_map.json and update window_states with new session associations.
 
         Keys in session_map are formatted as "tmux_session:window_id" (e.g. "ccgram:@12").
@@ -203,15 +229,15 @@ class SessionMapSync:
         with "emdash-") are both processed. Emdash windows are marked as external.
         Also cleans up window_states entries not in current session_map.
         Updates window_display_names from the "window_name" field in values.
+
+        If ``raw`` is provided (e.g., by ``read_session_map_raw``), use it
+        directly to avoid a redundant file read.  Otherwise read the file.
         """
-        if not config.session_map_file.exists():
-            return
-        try:
-            async with aiofiles.open(config.session_map_file, "r") as f:
-                content = await f.read()
-            session_map = json.loads(content)
-        except (json.JSONDecodeError, OSError):  # fmt: skip
+        if raw is None:
+            raw = await read_session_map_raw()
+        if not raw:
             return
+        session_map = raw
 
         prefix = f"{config.tmux_session_name}:"
         valid_wids, old_format_sids, old_format_keys, changed = (
@@ -403,6 +429,7 @@ class SessionMapSync:
                 "Pruning dead session_map entry: %s (window %s)", key, window_id
             )
             del raw[key]
+            _preserve_log_memo.pop(window_id, None)
             if window_store.has_window(window_id):
                 window_store.remove_window(window_id)
                 changed_state = True

{ccgram-3.3.2 → ccgram-3.3.3}/src/ccgram/session_monitor.py

@@ -29,14 +29,13 @@ from .event_reader import read_new_events
 from .idle_tracker import IdleTracker
 from .monitor_state import MonitorState
 from .providers import get_provider_for_window, registry  # noqa: F401 (used by test patches)
-from .session_map import parse_session_map
+from .session_map import parse_session_map, read_session_map_raw
 from .session_lifecycle import session_lifecycle
 from .tmux_manager import tmux_manager
 from .monitor_events import NewMessage, NewWindowEvent, SessionInfo
 from .transcript_reader import TranscriptReader
 from .utils import task_done_callback
 
-import aiofiles
 import json
 
 # Re-export for backward-compatible imports from other modules
@@ -58,8 +57,6 @@ _MSG_PREVIEW_LENGTH = 80
 
 logger = structlog.get_logger()
 
-_SessionMapError = (json.JSONDecodeError, OSError)
-
 
 class SessionMonitor:
     """Monitors Claude Code sessions for new assistant messages.
@@ -245,18 +242,20 @@ class SessionMonitor:
             except _CallbackError:
                 logger.exception("Hook event callback error for %s", event.event_type)
 
-    async def _load_current_session_map(self) -> dict[str, dict[str, str]]:
-        """Load current session_map and return window_key -> details mapping."""
-        if config.session_map_file.exists():
-            try:
-                async with aiofiles.open(config.session_map_file, "r") as f:
-                    content = await f.read()
-                raw = json.loads(content)
-                prefix = f"{config.tmux_session_name}:"
-                return parse_session_map(raw, prefix)
-            except _SessionMapError:
-                pass
-        return {}
+    async def _load_current_session_map(
+        self, raw: dict | None = None
+    ) -> dict[str, dict[str, str]]:
+        """Load current session_map and return window_key -> details mapping.
+
+        If ``raw`` is provided (already read by the caller), parse it directly
+        to avoid a redundant file read.  Otherwise read session_map.json.
+        """
+        if raw is None:
+            raw = await read_session_map_raw()
+        if not raw:
+            return {}
+        prefix = f"{config.tmux_session_name}:"
+        return parse_session_map(raw, prefix)
 
     async def _cleanup_all_stale_sessions(self) -> None:
         """Clean up all tracked sessions not in current session_map (startup)."""
@@ -275,9 +274,11 @@ class SessionMonitor:
                 self._idle_tracker.clear_session(session_id)
             self.state.save_if_dirty()
 
-    async def _detect_and_cleanup_changes(self) -> dict[str, dict[str, str]]:
+    async def _detect_and_cleanup_changes(
+        self, raw: dict | None = None
+    ) -> dict[str, dict[str, str]]:
         """Reconcile session_map; clean up replaced/removed sessions; fire new-window events."""
-        current_map = await self._load_current_session_map()
+        current_map = await self._load_current_session_map(raw)
         result = session_lifecycle.reconcile(current_map, self._idle_tracker)
 
         for session_id in result.sessions_to_remove:
@@ -336,9 +337,10 @@ class SessionMonitor:
         while self._running:
             try:
                 await self._read_hook_events()
-                await session_map_sync.load_session_map()
+                raw_session_map = await read_session_map_raw()
+                await session_map_sync.load_session_map(raw_session_map)
 
-                current_map = await self._detect_and_cleanup_changes()
+                current_map = await self._detect_and_cleanup_changes(raw_session_map)
 
                 all_windows = await tmux_manager.list_windows()
                 external_windows = await tmux_manager.discover_external_sessions()

{ccgram-3.3.2 → ccgram-3.3.3}/tests/integration/conftest.py

@@ -11,6 +11,13 @@ from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 
+# Trigger SessionManager construction so the window_store / thread_router /
+# session_map_sync proxies are wired before any integration test imports
+# session_monitor or related modules in isolation.  When the whole suite runs,
+# some other test usually imports ccgram.session first; explicit import here
+# guarantees per-file isolation.
+import ccgram.session  # noqa: F401  (import-for-side-effects)
+
 
 @pytest.fixture(autouse=True)
 def _default_replace_prompt_mode():