fix: preserve manually created tmux windows

Author: alexei-led

src/ccgram/handlers/directory_callbacks.py

@@ -27,6 +27,7 @@
 from ..session import session_manager
 from ..session_map import session_map_sync
 from ..user_preferences import user_preferences
+from ..window_state_store import CCGRAM_CREATED_WINDOW_ORIGIN
 from ..thread_router import thread_router
 from ..tmux_manager import send_to_window, tmux_manager
 from .callback_data import (
@@ -557,6 +558,7 @@ async def _create_window_and_bind(
         return
 
     user_preferences.update_user_mru(user_id, selected_path)
+    session_manager.set_window_origin(created_wid, CCGRAM_CREATED_WINDOW_ORIGIN)
     session_manager.set_window_cwd(created_wid, selected_path)
     session_manager.set_window_provider(created_wid, provider_name)
     session_manager.set_window_approval_mode(created_wid, approval_mode)

src/ccgram/handlers/msg_spawn.py

@@ -32,6 +32,7 @@
     spawns_dir,
 )
 from ..tmux_manager import tmux_manager
+from ..window_state_store import CCGRAM_CREATED_WINDOW_ORIGIN
 from .callback_registry import register
 from .message_sender import rate_limit_send_message
 
@@ -86,6 +87,7 @@ async def handle_spawn_approval(
     spawn_file = spawns_dir() / f"{request_id}.json"
     spawn_file.unlink(missing_ok=True)
 
+    session_manager.set_window_origin(window_id, CCGRAM_CREATED_WINDOW_ORIGIN)
     session_manager.set_window_provider(window_id, req.provider, cwd=req.cwd)
 
     try:

src/ccgram/handlers/recovery_callbacks.py

@@ -28,6 +28,7 @@
 from ..thread_router import thread_router
 from ..tmux_manager import send_to_window, tmux_manager
 from ..utils import read_session_metadata_from_jsonl
+from ..window_state_store import CCGRAM_CREATED_WINDOW_ORIGIN
 from .callback_data import (
     CB_RECOVERY_BACK,
     CB_RECOVERY_CANCEL,
@@ -382,6 +383,7 @@ async def _create_and_bind_window(
         await session_map_sync.wait_for_session_map_entry(created_wid)
 
     # Propagate provider to new window
+    session_manager.set_window_origin(created_wid, CCGRAM_CREATED_WINDOW_ORIGIN)
     session_manager.set_window_provider(created_wid, provider.capabilities.name)
     session_manager.set_window_approval_mode(created_wid, approval_mode)
 

src/ccgram/handlers/restore_command.py

@@ -21,6 +21,7 @@
 from ..session_map import session_map_sync
 from ..thread_router import thread_router
 from ..tmux_manager import tmux_manager
+from ..window_state_store import CCGRAM_CREATED_WINDOW_ORIGIN
 from .message_sender import safe_reply
 from .polling_strategies import lifecycle_strategy
 from .topic_emoji import format_topic_name_for_mode
@@ -83,6 +84,7 @@ async def restore_command(update: Update, context: ContextTypes.DEFAULT_TYPE) ->
     if provider.capabilities.supports_hook:
         await session_map_sync.wait_for_session_map_entry(wid)
 
+    session_manager.set_window_origin(wid, CCGRAM_CREATED_WINDOW_ORIGIN)
     session_manager.set_window_provider(wid, provider.capabilities.name)
     session_manager.set_window_approval_mode(wid, approval_mode)
     thread_router.bind_thread(user_id, thread_id, wid, window_name=wname)

src/ccgram/handlers/resume_command.py

@@ -33,6 +33,7 @@
 from ..session_map import session_map_sync
 from ..thread_router import thread_router
 from ..tmux_manager import tmux_manager
+from ..window_state_store import CCGRAM_CREATED_WINDOW_ORIGIN
 from ..utils import read_session_metadata_from_jsonl
 from .callback_data import CB_RESUME_CANCEL, CB_RESUME_PAGE, CB_RESUME_PICK
 from .callback_helpers import get_thread_id
@@ -322,6 +323,7 @@ async def _create_resume_window(
     if success:
         if provider.capabilities.supports_hook:
             await session_map_sync.wait_for_session_map_entry(created_wid)
+        session_manager.set_window_origin(created_wid, CCGRAM_CREATED_WINDOW_ORIGIN)
         session_manager.set_window_provider(created_wid, provider.capabilities.name)
         session_manager.set_window_approval_mode(created_wid, approval_mode)
 

src/ccgram/handlers/sync_command.py

@@ -211,6 +211,9 @@ async def _close_ghost_topics(bot: Bot, issues: list[AuditIssue]) -> int:
         user_id = int(match.group(1))
         thread_id = int(match.group(2))
         window_id = match.group(3)
+        current_window_id = thread_router.get_window_for_thread(user_id, thread_id)
+        if current_window_id != window_id:
+            continue
         chat_id = thread_router.resolve_chat_id(user_id, thread_id)
         topic_removed = False
         if chat_id == user_id:
@@ -345,6 +348,9 @@ async def _recreate_dead_topics(bot: Bot, issues: list[AuditIssue]) -> int:
         user_id = int(match.group(1))
         thread_id = int(match.group(2))
         window_id = match.group(3)
+        current_window_id = thread_router.get_window_for_thread(user_id, thread_id)
+        if current_window_id != window_id:
+            continue
 
         view = window_query.view_window(window_id)
         name = (view.window_name if view else "") or thread_router.get_display_name(
@@ -435,10 +441,10 @@ async def handle_sync_fix(query: CallbackQuery) -> None:
 
     await _sync_live_topic_names(bot, live_ids)
 
-    # Enforcement: close ghost topics, recreate dead topics, adopt orphans
+    # Enforcement: adopt orphans first so stale same-name topics can be rebound.
+    await _adopt_orphaned_windows(bot, pre_audit.issues)
     closed_count = await _close_ghost_topics(bot, pre_audit.issues)
     recreated_count = await _recreate_dead_topics(bot, pre_audit.issues)
-    await _adopt_orphaned_windows(bot, pre_audit.issues)
 
     # Re-audit and compute actual fixed count (handles partial failures).
     # No skip_threads here: successful recreations use a new thread_id (old

src/ccgram/handlers/topic_lifecycle.py

@@ -23,6 +23,7 @@
 from ..tmux_manager import tmux_manager
 from ..utils import log_throttled
 from ..window_resolver import is_foreign_window
+from ..window_state_store import CCGRAM_CREATED_WINDOW_ORIGIN
 from .cleanup import clear_topic_state
 from .message_sender import is_thread_gone
 from .polling_strategies import (
@@ -126,10 +127,15 @@ async def check_unbound_window_ttl(
 
     now = time.monotonic()
     for w in live_windows:
-        if w.window_id not in bound_ids and not is_foreign_window(w.window_id):
-            ws = terminal_poll_state.get_state(w.window_id)
-            if ws.unbound_timer is None:
-                terminal_poll_state.set_unbound_timer(w.window_id, now)
+        if w.window_id in bound_ids or is_foreign_window(w.window_id):
+            continue
+        view = session_manager.view_window(w.window_id)
+        if view is None or view.origin != CCGRAM_CREATED_WINDOW_ORIGIN:
+            terminal_poll_state.clear_unbound_timer(w.window_id)
+            continue
+        ws = terminal_poll_state.get_state(w.window_id)
+        if ws.unbound_timer is None:
+            terminal_poll_state.set_unbound_timer(w.window_id, now)
 
     await _kill_expired_unbound(now, timeout)
     _prune_orphaned_poll_state(live_ids, bound_ids)
@@ -188,14 +194,18 @@ async def probe_topic_existence(bot: Bot) -> None:
                 or "thread not found" in e.message.lower()
             ):
                 w = await tmux_manager.find_window_by_id(wid)
-                if w:
+                view = session_manager.view_window(wid)
+                killed = False
+                if w and view and view.origin == CCGRAM_CREATED_WINDOW_ORIGIN:
                     await tmux_manager.kill_window(w.window_id)
+                    killed = True
                 terminal_poll_state.reset_probe_failures(wid)
                 await clear_topic_state(user_id, thread_id, bot, window_id=wid)
                 thread_router.unbind_thread(user_id, thread_id)
+                action = "killed" if killed else "unbound"
                 logger.info(
-                    "Topic deleted: killed window_id '%s' and "
-                    "unbound thread %d for user %d",
+                    "Topic deleted: %s window_id '%s' and unbound thread %d for user %d",
+                    action,
                     wid,
                     thread_id,
                     user_id,

src/ccgram/handlers/topic_orchestration.py

@@ -11,6 +11,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import time
 from pathlib import Path
 
@@ -28,6 +29,8 @@
 from ..session_monitor import NewWindowEvent
 from ..thread_router import thread_router
 from ..tmux_manager import tmux_manager
+from .message_sender import is_thread_gone
+from .topic_emoji import strip_emoji_prefix
 
 logger = structlog.get_logger()
 
@@ -192,11 +195,88 @@ async def create_topic_in_chat(
         )
 
 
+async def _topic_exists(bot: Bot, chat_id: int, thread_id: int) -> bool | None:
+    """Probe a Telegram topic. True=exists, False=gone, None=unknown."""
+    try:
+        msg = await bot.send_message(
+            chat_id,
+            "\u200b",
+            message_thread_id=thread_id,
+            disable_notification=True,
+        )
+    except TelegramError as exc:
+        if is_thread_gone(exc):
+            return False
+        return None
+    with contextlib.suppress(TelegramError):
+        await bot.delete_message(chat_id, msg.message_id)
+    return True
+
+
+async def _rebind_existing_topic_by_name(
+    event: NewWindowEvent, bot: Bot, topic_name: str
+) -> bool:
+    """Bind a stale same-name topic to a newly discovered manual window."""
+    clean_topic_name = strip_emoji_prefix(topic_name)
+    matches: list[tuple[int, int, str, int]] = []
+    bindings = list(thread_router.iter_thread_bindings())
+    for user_id, thread_id, old_window_id in bindings:
+        if old_window_id == event.window_id:
+            continue
+        display_name = strip_emoji_prefix(thread_router.get_display_name(old_window_id))
+        if display_name != clean_topic_name:
+            continue
+        if await tmux_manager.find_window_by_id(old_window_id):
+            continue
+        chat_id = thread_router.resolve_chat_id(user_id, thread_id)
+        if chat_id == user_id:
+            continue
+        matches.append((user_id, thread_id, old_window_id, chat_id))
+
+    if len(matches) != 1:
+        if len(matches) > 1:
+            logger.warning(
+                "Multiple stale same-name topics for window %s (%s); not rebinding",
+                event.window_id,
+                clean_topic_name,
+            )
+        return False
+
+    user_id, thread_id, old_window_id, chat_id = matches[0]
+    exists = await _topic_exists(bot, chat_id, thread_id)
+    if exists is False:
+        thread_router.unbind_thread(user_id, thread_id)
+        logger.info(
+            "Dropped dead same-name topic thread %d for stale window %s",
+            thread_id,
+            old_window_id,
+        )
+        return False
+    if exists is None:
+        logger.info(
+            "Could not probe same-name topic thread %d for stale window %s; not rebinding",
+            thread_id,
+            old_window_id,
+        )
+        return False
+
+    thread_router.bind_thread(user_id, thread_id, event.window_id, window_name=topic_name)
+    thread_router.set_group_chat_id(user_id, thread_id, chat_id)
+    logger.info(
+        "Rebound existing topic thread %d from stale window %s to new window %s (%s)",
+        thread_id,
+        old_window_id,
+        event.window_id,
+        clean_topic_name,
+    )
+    return True
+
+
 async def handle_new_window(event: NewWindowEvent, bot: Bot) -> None:
-    """Create a Telegram forum topic for a newly detected tmux window.
+    """Create or bind a Telegram forum topic for a newly detected tmux window.
 
-    Skips if the window is already bound to a topic. Creates one topic per
-    unique group chat, binds all users in that chat.
+    Skips if the window is already bound. Reuses one stale same-name topic when
+    it still exists; otherwise creates one topic per unique group chat.
     """
     if _is_window_already_bound(event.window_id):
         logger.debug(
@@ -207,6 +287,9 @@ async def handle_new_window(event: NewWindowEvent, bot: Bot) -> None:
     await _auto_detect_provider(event.window_id)
 
     topic_name = event.window_name or Path(event.cwd).name or event.window_id
+    if await _rebind_existing_topic_by_name(event, bot, topic_name):
+        return
+
     seen_chats = collect_target_chats(event.window_id)
     if not seen_chats:
         return

src/ccgram/session.py

@@ -561,6 +561,7 @@ def view_window(self, window_id: str) -> WindowView | None:
             window_name=ws.window_name,
             session_id=ws.session_id,
             external=ws.external,
+            origin=ws.origin,
         )
 
     @property
@@ -611,6 +612,10 @@ def set_window_cwd(self, window_id: str, cwd: str) -> None:
         state.cwd = cwd
         self._save_state()
 
+    def set_window_origin(self, window_id: str, origin: str) -> None:
+        """Set the lifecycle origin for a window and persist state."""
+        window_store.set_window_origin(window_id, origin)
+
     def get_approval_mode(self, window_id: str) -> str:
         """Get approval mode for a window (default: 'normal')."""
         state = self.window_states.get(window_id)

src/ccgram/session_lifecycle.py

@@ -38,6 +38,7 @@ class ReconcileResult:
 
     sessions_to_remove: set[str] = field(default_factory=set)
     new_windows: dict[str, dict[str, Any]] = field(default_factory=dict)
+    changed_windows: dict[str, dict[str, Any]] = field(default_factory=dict)
     current_map: dict[str, dict[str, Any]] = field(default_factory=dict)
 
 
@@ -85,6 +86,7 @@ def reconcile(
                     new_details["session_id"],
                 )
                 result.sessions_to_remove.add(old_details["session_id"])
+                result.changed_windows[window_id] = new_details
                 idle_tracker.clear_session(old_details["session_id"])
                 claude_task_state.clear_window(window_id)