claude-code-tools 1.29.0__tar.gz → 1.29.2__tar.gz

{claude_code_tools-1.29.0 → claude_code_tools-1.29.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-tools
-Version: 1.29.0
+Version: 1.29.2
 Summary: Collection of tools for working with Claude Code
 License-File: LICENSE
 Requires-Python: >=3.11

{claude_code_tools-1.29.0 → claude_code_tools-1.29.2}/claude_code_tools/__init__.py

@@ -1,3 +1,3 @@
 """Claude Code Tools - Collection of utilities for Claude Code."""
 
-__version__ = "1.29.0"
+__version__ = "1.29.2"

{claude_code_tools-1.29.0 → claude_code_tools-1.29.2}/claude_code_tools/agent_tunnel/config.py

@@ -104,6 +104,10 @@ class MattermostConfig:
     allowed_user_ids: list[str] = field(default_factory=list)
     # false only for a self-signed test server.
     verify_tls: bool = True
+    # Handle answered when a teammate just @-mentions the bot without naming
+    # a handle ("@bot how does X work?"). Empty = use the only shared session
+    # when exactly one is live, else ask which.
+    default_handle: str = ""
 
 
 @dataclass
@@ -385,6 +389,10 @@ respond_to_dms = false
 # channel_ids = []        # 26-char channel ids
 # allowed_user_ids = []   # empty = anyone in the watched channels
 # verify_tls = true
+# Handle answered when someone just @-mentions the bot without naming one
+# ("@bot how does X work?"). Unset = the only shared session when exactly
+# one is live, else the bot asks which.
+# default_handle = ""
 
 [claude]
 binary = "claude"

{claude_code_tools-1.29.0 → claude_code_tools-1.29.2}/claude_code_tools/agent_tunnel/mattermost_bot.py

@@ -141,11 +141,23 @@ def parse_posted(event: dict[str, Any]) -> Optional[MMPost]:
     )
 
 
+def resolve_default_handle(cfg: TunnelConfig, live: Sequence[str]) -> str:
+    """Handle to answer for a bare ``@bot`` mention.
+
+    The configured ``default_handle`` wins. With none set, a single shared
+    session is unambiguous; with several, the bot asks which one.
+    """
+    if cfg.mattermost.default_handle:
+        return cfg.mattermost.default_handle
+    return live[0] if len(live) == 1 else ""
+
+
 @dataclass
 class Route:
     """What the bot should do with one post."""
 
-    action: str  # ignore | list | open | unknown_handle | followup | close
+    # ignore | list | open | unknown_handle | which_handle | followup | close
+    action: str
     thread_key: str = ""
     root_id: str = ""
     handle: str = ""
@@ -161,6 +173,7 @@ def route_post(
     allowed_user_ids: Sequence[str],
     is_bound: Callable[[str], bool],
     handle_live: Callable[[str], bool],
+    default_handle: str = "",
 ) -> Route:
     """Decide what to do with a post (pure; no I/O).
 
@@ -172,6 +185,8 @@ def route_post(
         allowed_user_ids: If non-empty, only these users are answered.
         is_bound: Whether a thread key is bound to a session.
         handle_live: Whether a handle is currently shared.
+        default_handle: Handle to use when the bot is @-mentioned without
+            one (see ``resolve_default_handle``); "" = ask which.
 
     Returns:
         The routing decision.
@@ -194,7 +209,18 @@ def route_post(
     if post.root_id:
         key = f"mm:{post.root_id}"
         if not is_bound(key):
-            return ignore
+            # Not our thread yet. Teammates still address the bot inside one
+            # (e.g. answering its "which session?" question), so an explicit
+            # handle or @bot mention opens a binding on that root; anything
+            # else stays ignored.
+            return _open_route(
+                text,
+                post_id=post.root_id,
+                bot_username=bot_username,
+                handle_live=handle_live,
+                default_handle=default_handle,
+                complain_unknown=False,
+            )
         # A reply that opens with @someone-else (or @all/@channel/@here) is
         # teammates talking among themselves. A leading @bot is stripped.
         who = leading_mention(text)
@@ -208,21 +234,74 @@ def route_post(
             return Route("close", thread_key=key, root_id=post.root_id)
         return Route("followup", thread_key=key, root_id=post.root_id, text=text)
 
+    return _open_route(
+        text,
+        post_id=post.id,
+        bot_username=bot_username,
+        handle_live=handle_live,
+        default_handle=default_handle,
+    )
+
+
+def _open_route(
+    text: str,
+    *,
+    post_id: str,
+    bot_username: str,
+    handle_live: Callable[[str], bool],
+    default_handle: str,
+    complain_unknown: bool = True,
+) -> Route:
+    """Route a message that may open a thread on ``post_id`` (pure).
+
+    Used for a root post and for a message inside a thread the bot has not
+    bound yet: both are "someone addressing the bot in the channel".
+    ``complain_unknown`` is off in the latter case, so ordinary chatter
+    there stays unanswered.
+    """
+    ignore = Route("ignore")
+    # An @bot mention is how a teammate naturally addresses the bot. Strip
+    # it; whatever follows is the question (a handle may still lead it).
+    mentioned = False
+    who = leading_mention(text)
+    if who is not None:
+        if who in BROADCAST_MENTIONS or who != bot_username.lower():
+            return ignore  # teammates talking to each other
+        mentioned = True
+        text = _MENTION_RE.sub("", text.lstrip(), count=1).strip()
+
     if is_list_command(text):
-        return Route("list", root_id=post.id)
-    token, _, remainder = text.partition(" ")
-    handle = token.strip().lower()
+        return Route("list", root_id=post_id)
+    # Split on ANY whitespace: a handle followed by a newline is still a
+    # handle, and must not fall through to the default.
+    parts = text.split(None, 1)
+    handle = parts[0].strip().lower() if parts else ""
+    remainder = parts[1].strip() if len(parts) > 1 else ""
     if handle_live(handle):
         return Route(
             "open",
-            thread_key=f"mm:{post.id}",
-            root_id=post.id,
+            thread_key=f"mm:{post_id}",
+            root_id=post_id,
             handle=handle,
-            text=remainder.strip(),
+            text=remainder,
         )
-    # Only complain if it clearly looks like a handle attempt.
-    if HANDLE_RE.match(handle) and not remainder:
-        return Route("unknown_handle", root_id=post.id, handle=handle)
+    if mentioned:
+        # Addressed to the bot but no handle named: answer the default one,
+        # but only while it is actually shared.
+        if not default_handle or not handle_live(default_handle):
+            return Route("which_handle", root_id=post_id)
+        return Route(
+            "open",
+            thread_key=f"mm:{post_id}",
+            root_id=post_id,
+            handle=default_handle,
+            text=text,
+        )
+    # Only complain if it clearly looks like a handle attempt — and never
+    # inside someone else's thread, where a one-word reply ("thanks") would
+    # otherwise draw a "no live session" answer.
+    if complain_unknown and HANDLE_RE.match(handle) and not remainder:
+        return Route("unknown_handle", root_id=post_id, handle=handle)
     return ignore
 
 
@@ -553,6 +632,9 @@ class _Router:
             allowed_user_ids=self.cfg.mattermost.allowed_user_ids,
             is_bound=lambda key: relay.store.get(key) is not None,
             handle_live=lambda h: self.registry.get(h) is not None,
+            default_handle=resolve_default_handle(
+                self.cfg, [r.handle for r in self.registry.active()]
+            ),
         )
         if route.action == "ignore":
             return
@@ -560,6 +642,13 @@ class _Router:
         sender = post.sender or "A teammate"
         if route.action == "list":
             await dest.send(relay.handles_text())
+        elif route.action == "which_handle":
+            live = self.registry.active()
+            example = live[0].handle if live else "handle"
+            await dest.send(
+                "Which session should I ask? Put its handle first, e.g. "
+                f"`{example} your question`.\n\n" + relay.handles_text()
+            )
         elif route.action == "unknown_handle":
             await dest.send(
                 f"No live session for handle `{route.handle}`. "

{claude_code_tools-1.29.0 → claude_code_tools-1.29.2}/claude_code_tools/tmux_cli_controller.py

@@ -914,11 +914,8 @@ class CLI:
                 print(str(e))
         else:
             # Remote mode - kill window
-            try:
-                self.controller.kill_window(window_id=pane)
-                print("Window killed")
-            except ValueError as e:
-                print(str(e))
+            self.controller.kill_window(window_id=pane)
+            print("Window killed")
     
     def wait_idle(self, pane: Optional[str] = None, idle_time: float = 2.0, 
                   timeout: Optional[int] = None):

{claude_code_tools-1.29.0 → claude_code_tools-1.29.2}/claude_code_tools/tmux_remote_controller.py

@@ -3,7 +3,7 @@
 Remote Tmux Controller
 
 Enables tmux-cli to work when run outside of tmux by:
-- Auto-creating a detached tmux session on first use
+- Creating a detached tmux session when launching a managed window
 - Managing commands in separate tmux windows (not panes)
 - Providing an API compatible with the local (pane) controller
 """
@@ -16,65 +16,141 @@ from typing import Optional, List, Dict, Tuple, Union, Any
 
 class RemoteTmuxController:
     """Remote controller that manages a dedicated tmux session and windows."""
+
+    _ready_option = '@tmux_cli_ready'
     
     def __init__(self, session_name: str = "remote-cli-session"):
-        """Initialize with session name and ensure the session exists."""
+        """Initialize with a managed session name without creating it."""
         self.session_name = session_name
-        self.target_window: Optional[str] = None  # e.g., "session:0" (active pane in that window)
+        self.target_window: Optional[str] = None  # Stable window ID, e.g., "@1"
         print(f"Note: tmux-cli is running outside tmux. Managing windows in session '{session_name}'.")
         print("For better integration, consider running from inside a tmux session.")
         print("Use 'tmux-cli attach' to view the remote session.")
-        self._ensure_session()
     
     # ----------------------------
     # Internal utilities
     # ----------------------------
-    def _run_tmux(self, args: List[str]) -> Tuple[str, int]:
-        result = subprocess.run(
-            ['tmux'] + args,
-            capture_output=True,
-            text=True
+    def _run_tmux(self, args: List[str], include_stderr: bool = False) -> Tuple[str, int]:
+        try:
+            result = subprocess.run(
+                ['tmux'] + args,
+                capture_output=True,
+                text=True
+            )
+        except OSError as exc:
+            raise RuntimeError(f"Could not run tmux {args[0]}: {exc}") from exc
+        output = result.stdout.strip()
+        if include_stderr and result.returncode != 0:
+            output = "\n".join(part for part in (output, result.stderr.strip()) if part)
+        return output, result.returncode
+
+    @staticmethod
+    def _session_is_missing(error: str) -> bool:
+        """Recognize tmux's absent-session and absent-server diagnostics only."""
+        return (
+            "can't find session:" in error
+            or error.startswith("no server running on ")
+            or (error.startswith("error connecting to ") and "(No such file or directory)" in error)
         )
-        return result.stdout.strip(), result.returncode
+
+    @staticmethod
+    def _tmux_failure(action: str, output: str, code: int) -> RuntimeError:
+        detail = f": {output}" if output else ""
+        return RuntimeError(f"tmux {action} failed (exit {code}){detail}")
+
+    @staticmethod
+    def _window_is_missing(error: str, window_id: str) -> bool:
+        """Only classify a diagnostic for this exact stable ID as a vanished window."""
+        return error.strip() in (
+            f"no such window: {window_id}",
+            f"can't find window: {window_id}",
+        )
+
+    def _managed_session_exists(self) -> bool:
+        output, code = self._run_tmux(['has-session', '-t', f'={self.session_name}'], include_stderr=True)
+        if code == 0:
+            return True
+        if self._session_is_missing(output):
+            return False
+        raise self._tmux_failure('has-session', output, code)
     
     def _ensure_session(self) -> None:
-        """Create the session if it doesn't exist (detached)."""
-        _, code = self._run_tmux(['has-session', '-t', self.session_name])
-        if code != 0:
+        """Create the managed session if needed for a new window."""
+        if not self._managed_session_exists():
             # Create a detached session using user's default shell
             # Return the session name just to force creation
-            self._run_tmux([
+            output, code = self._run_tmux([
                 'new-session', '-d', '-s', self.session_name, '-P', '-F', '#{session_name}'
-            ])
-            # Remember first window as default target
-            self.target_window = f"{self.session_name}:0"
-        else:
-            # If already exists and we don't have a target, set to active window
-            if not self.target_window:
-                win, code2 = self._run_tmux(['display-message', '-p', '-t', self.session_name, '#{session_name}:#{window_index}'])
-                if code2 == 0 and win:
-                    self.target_window = win
+            ], include_stderr=True)
+            if code != 0:
+                # Another launcher may have won the check/create race.
+                if output != f'duplicate session: {self.session_name}' or not self._managed_session_exists():
+                    raise self._tmux_failure('new-session', output, code)
+            elif not output:
+                raise self._tmux_failure('new-session', output, code)
     
     def _window_target(self, pane: Optional[str]) -> str:
         """Resolve user-provided pane/window hint to a tmux target.
         Accepts:
-        - None -> use last target window if set else active window in session
+        - None -> use last target window if set else a ready active window in session
         - digits (e.g., "1") -> session:index
         - full tmux target (e.g., "name:1" or "name:1.0" or "%12") -> pass-through
         """
-        self._ensure_session()
         if pane is None:
             if self.target_window:
-                return self.target_window
-            # Fallback to active window in session
-            win, code = self._run_tmux(['display-message', '-p', '-t', self.session_name, '#{session_name}:#{window_index}'])
-            if code == 0 and win:
-                self.target_window = win
-                return win
-            # Final fallback: session:0
-            return f"{self.session_name}:0"
+                # Window IDs can be reused after a server restart. Check both
+                # membership and readiness before trusting a cached default.
+                windows, code = self._run_tmux(
+                    ['list-windows', '-t', f'={self.session_name}',
+                     '-F', '#{window_id}|#{@tmux_cli_ready}'],
+                    include_stderr=True,
+                )
+                if code != 0 and not self._session_is_missing(windows):
+                    raise self._tmux_failure('list-windows', windows, code)
+                expected = f'{self.target_window}|{self.target_window}'
+                if code == 0 and expected in windows.splitlines():
+                    return self.target_window
+                self.target_window = None
+                if code != 0:
+                    raise ValueError(
+                        "No target pane/window specified; managed session "
+                        f"'{self.session_name}' does not exist. "
+                        "Launch a window or pass --pane."
+                    )
+            # An existing managed session may have been created by an earlier CLI call.
+            win, code = self._run_tmux(
+                ['display-message', '-p', '-t', f'={self.session_name}:',
+                 '#{window_id}|#{@tmux_cli_ready}'],
+                include_stderr=True,
+            )
+            if code == 0:
+                if not win:
+                    raise self._tmux_failure('display-message', win, code)
+                window_id, separator, ready = win.partition('|')
+                if not separator or not window_id.startswith('@'):
+                    raise self._tmux_failure('display-message', win, code)
+                if ready == window_id:
+                    self.target_window = window_id
+                    return window_id
+                raise ValueError(
+                    f"No target pane/window specified; managed session '{self.session_name}' "
+                    "has no successfully launched active window. Launch a window or pass --pane."
+                )
+            if code != 0 and not (self._session_is_missing(win) or "can't find window:" in win):
+                raise self._tmux_failure('display-message', win, code)
+            raise ValueError(
+                f"No target pane/window specified; managed session '{self.session_name}' "
+                "does not exist or has no active window. Launch a window or pass --pane."
+            )
         # If user supplied a simple index
-        if isinstance(pane, str) and pane.isdigit():
+        if isinstance(pane, bool):
+            raise ValueError("Boolean --pane is not a window index")
+        if type(pane) is int or (isinstance(pane, str) and pane.isdigit()):
+            if not self._managed_session_exists():
+                raise ValueError(
+                    f"Managed session '{self.session_name}' does not exist; "
+                    "launch a window or pass a full --pane target."
+                )
             return f"{self.session_name}:{pane}"
         # Otherwise assume user provided a pane/window target or pane id
         return pane
@@ -92,7 +168,6 @@ class RemoteTmuxController:
         Returns a list shaped similarly to local list_panes, with keys:
         id (window target), index, title (window name), active (bool), size (N/A)
         """
-        self._ensure_session()
         out, code = self._run_tmux([
             'list-windows', '-t', self.session_name,
             '-F', '#{window_index}|#{window_name}|#{window_active}|#{window_width}x#{window_height}'
@@ -117,17 +192,49 @@ class RemoteTmuxController:
         """Launch a command in a new window within the managed session.
         Returns the window target (e.g., "session:1").
         """
-        self._ensure_session()
-        args = ['new-window', '-t', self.session_name, '-P', '-F', '#{session_name}:#{window_index}']
-        if name:
-            args.extend(['-n', name])
-        if command:
-            args.append(command)
-        out, code = self._run_tmux(args)
-        if code == 0 and out:
-            self.target_window = out
-            return out
-        return None
+        previous_target = self.target_window
+        try:
+            self._ensure_session()
+            args = ['new-window', '-t', f'={self.session_name}:', '-P', '-F',
+                    '#{session_name}:#{window_index}|#{window_id}']
+            if name:
+                args.extend(['-n', name])
+            if command:
+                args.append(command)
+            out, code = self._run_tmux(args, include_stderr=True)
+            if code != 0 or not out:
+                raise self._tmux_failure('new-window', out, code)
+            target, separator, window_id = out.partition('|')
+            if not separator or not target or not window_id.startswith('@'):
+                raise self._tmux_failure('new-window', out, code)
+            try:
+                marked, mark_code = self._run_tmux(
+                    ['set-option', '-w', '-t', window_id, self._ready_option, window_id],
+                    include_stderr=True,
+                )
+            except RuntimeError as exc:
+                raise RuntimeError(
+                    f"Ready mark for created window {window_id} could not be set; "
+                    f"command may have started. {exc}"
+                ) from exc
+            if mark_code != 0:
+                if self._window_is_missing(marked, window_id):
+                    raise RuntimeError(
+                        f"Command was launched in window {window_id}, but that window "
+                        f"disappeared before its ready mark; no live target is available "
+                        f"(tmux set-option exit {mark_code}: {marked}). "
+                        "The command may have run; do not retry automatically."
+                    )
+                raise RuntimeError(
+                    f"{self._tmux_failure('set-option', marked, mark_code)}; "
+                    f"created window {window_id}; command may have started. "
+                    "Inspect the window before retrying."
+                )
+            self.target_window = window_id
+            return target
+        except Exception:
+            self.target_window = previous_target
+            raise
     
     def send_keys(self, text: str, pane_id: Optional[str] = None, enter: bool = True,
                   delay_enter: Union[bool, float] = True, verify_enter: bool = True,
@@ -272,14 +379,25 @@ class RemoteTmuxController:
 
     def kill_window(self, window_id: Optional[str] = None):
         target = self._window_target(window_id)
+        cached_target = target
+        if self.target_window and target != self.target_window:
+            resolved, code = self._run_tmux(
+                ['display-message', '-p', '-t', target, '#{window_id}']
+            )
+            if code == 0 and resolved:
+                cached_target = resolved
         # Ensure the target refers to a window (not a %pane id)
         # If user passed a pane id like %12, tmux can still resolve to its window
         self._run_tmux(['kill-window', '-t', target])
-        if self.target_window == target:
+        if self.target_window == cached_target:
             self.target_window = None
     
     def attach_session(self):
-        self._ensure_session()
+        if not self._managed_session_exists():
+            raise ValueError(
+                f"Managed session '{self.session_name}' does not exist; "
+                "launch a window before attaching."
+            )
         # Attach will replace the current terminal view until the user detaches
         subprocess.run(['tmux', 'attach-session', '-t', self.session_name])
     
@@ -289,7 +407,6 @@ class RemoteTmuxController:
     
     def list_windows(self) -> List[Dict[str, str]]:
         """List all windows in the managed session with basic info."""
-        self._ensure_session()
         out, code = self._run_tmux(['list-windows', '-t', self.session_name, '-F', '#{window_index}|#{window_name}|#{window_active}'])
         if code != 0 or not out:
             return []

{claude_code_tools-1.29.0 → claude_code_tools-1.29.2}/docs/agent-tunnel-spec.md

@@ -236,6 +236,14 @@ Daemon + core — `claude_code_tools/agent_tunnel/`:
 Mattermost routes the same way, with Mattermost's thread model: a root post
 `\<handle\> [question]` in a watched channel (26-char `channel_ids`) opens a
 thread keyed `mm:<root post id>`, and the bot answers as replies under it.
+A root post that simply **@-mentions the bot** works too — the mention is
+stripped and what follows is the question, answered against
+`[mattermost] default_handle` (unset: the only shared session when exactly
+one is live, else the bot replies asking which handle to use). A handle may
+still lead the question after the mention.
+A message inside a thread the bot has NOT bound is routed the same way as a
+root post (so a teammate can answer the bot's "which session?" question
+in place); anything else there is left alone.
 Replies in a bound thread are follow-ups; a reply opening with
 `@someone-else`, `@all`, `@channel` or `@here` is side-chat and ignored, and
 a leading `@bot` is stripped. `!list`/`!handles` and `!done`/`!close`/`!end`

{claude_code_tools-1.29.0 → claude_code_tools-1.29.2}/docs/tmux-cli-instructions.md

@@ -5,27 +5,40 @@ Automatically detects whether you're inside or outside tmux and uses the appropr
 
 ## Auto-Detection
 - **Inside tmux (Local Mode)**: Manages panes in your current tmux window
-- **Outside tmux (Remote Mode)**: Creates and manages a separate tmux session with windows
+- **Outside tmux (Remote Mode)**: Manages windows in a separate tmux session, creating it when `launch` first needs it
+
+Remote `status`, `list_panes`, and `list_windows` do not create a session.
+An explicit full pane target (such as `%12` or `myapp:1.2`) works without a
+managed session. Commands without a target require an active window from a
+successful managed `launch`; otherwise, launch a window first or pass `--pane`.
+`attach` requires the managed session to already exist.
 
 ## Prerequisites
 - tmux must be installed
 - The `tmux-cli` command must be available (installed via `uv tool install`)
 
-## Pane Identification
+## Target Identification
 
-Panes can be specified in two simple ways:
+In local mode, panes can be specified in two simple ways:
 - Just the pane number (e.g., `2`) - refers to pane 2 in the current window
 - Full format: `session:window.pane` (e.g., `myapp:1.2`) - for any pane in any session
 
+In remote mode, `launch` returns a window target such as `remote-cli-session:1`.
+Use the returned target as `--pane`. A bare number such as `1` means a managed
+window index, not a pane index; window indices can change if windows move.
+Numeric `--pane=2` examples below show local mode unless labeled as remote.
+
 ## ⚠️ IMPORTANT: Always Launch a Shell First!
 
 **Always launch zsh first** to prevent losing output when commands fail:
 ```bash
-tmux-cli launch "zsh"  # Do this FIRST
-tmux-cli send "your-command" --pane=2  # Then run commands
+tmux-cli launch "zsh"  # Do this FIRST; remote example returns remote-cli-session:1
+tmux-cli send "your-command" --pane=remote-cli-session:1  # Use the actual returned target
 ```
 
-If you launch a command directly and it errors, the pane closes immediately and you lose all output!
+If a directly launched command exits before its remote window is marked ready,
+`launch` reports that the command was launched but has no live target. It does
+not retry the command. Launch a shell first to keep output available.
 
 ## Core Commands
 
@@ -33,7 +46,8 @@ If you launch a command directly and it errors, the pane closes immediately and
 ```bash
 tmux-cli launch "command"
 # Example: tmux-cli launch "python3"
-# Returns: pane identifier (e.g., session:window.pane format like myapp:1.2)
+# Local return: pane identifier (e.g., myapp:1.2)
+# Remote return: window target (e.g., remote-cli-session:1)
 ```
 
 ### Send input to a pane
@@ -159,23 +173,23 @@ tmux-cli help
 
 1. **ALWAYS launch a shell first** (prefer zsh) - this prevents losing output on errors:
    ```bash
-   tmux-cli launch "zsh"  # Returns pane identifier - DO THIS FIRST!
+   tmux-cli launch "zsh"  # Remote: returns a window target - DO THIS FIRST!
    ```
 
 2. Run your command in the shell:
    ```bash
-   tmux-cli send "python script.py" --pane=2
+   tmux-cli send "python script.py" --pane=remote-cli-session:1  # Use the actual returned target
    ```
 
 3. Interact with the program:
    ```bash
-   tmux-cli send "user input" --pane=2
-   tmux-cli capture --pane=2  # Check output
+   tmux-cli send "user input" --pane=remote-cli-session:1
+   tmux-cli capture --pane=remote-cli-session:1  # Check output
    ```
 
 4. Clean up when done:
    ```bash
-   tmux-cli kill --pane=2
+   tmux-cli kill --pane=remote-cli-session:1
    ```
 
 ## Remote Mode Specific Commands
@@ -205,7 +219,8 @@ tmux-cli list_windows
 - Use `capture` to check the current state before sending input
 - Use `status` to see all available panes and their current state
 - In local mode: Pane identifiers can be session:window.pane format (like `myapp:1.2`) or just pane indices like `1`, `2`
-- In remote mode: Window IDs can be indices like `0`, `1` or full form like `session:0.0`
+- In remote mode: Bare numbers like `0`, `1` are window indices; `launch` returns
+  a `session:window_index` target, such as `remote-cli-session:1`
 - If you launch a command directly (not via shell), the pane/window closes when
   the command exits
 - **IMPORTANT**: The tool prevents you from killing your own pane/window to avoid
@@ -222,4 +237,4 @@ tmux-cli wait_idle --pane=2 --idle-time=3.0
 
 # Now capture the result
 tmux-cli capture --pane=2
-```
+```

{claude_code_tools-1.29.0 → claude_code_tools-1.29.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "claude-code-tools"
-version = "1.29.0"
+version = "1.29.2"
 description = "Collection of tools for working with Claude Code"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -113,7 +113,7 @@ markers = [
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "1.29.0"
+version = "1.29.2"
 tag_format = "v$version"
 version_files = [
     "pyproject.toml:version",