claude-code-tools 1.29.4__tar.gz → 1.29.6__tar.gz

{claude_code_tools-1.29.4 → claude_code_tools-1.29.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-tools
-Version: 1.29.4
+Version: 1.29.6
 Summary: Collection of tools for working with Claude Code
 License-File: LICENSE
 Requires-Python: >=3.11
@@ -47,6 +47,15 @@ Everything — installation, every tool, plugins, and guides — lives in the
 docs. Click a card below to jump to a feature, or
 **[read the full docs](https://pchalasani.github.io/claude-code-tools/)**.
 
+Skills install with one command (`-s` picks one skill, `-g` installs for
+every project). Most work in any agent; a few are Claude Code and Codex
+only (see the [Plugins page](https://pchalasani.github.io/claude-code-tools/getting-started/plugins/)).
+Needs Node.js 22.20 or newer for `npx`:
+
+```bash
+npx skills add pchalasani/claude-code-tools -s voxtype-install
+```
+
 <div align="center">
 
 <table>

{claude_code_tools-1.29.4 → claude_code_tools-1.29.6}/README.md

@@ -21,6 +21,15 @@ Everything — installation, every tool, plugins, and guides — lives in the
 docs. Click a card below to jump to a feature, or
 **[read the full docs](https://pchalasani.github.io/claude-code-tools/)**.
 
+Skills install with one command (`-s` picks one skill, `-g` installs for
+every project). Most work in any agent; a few are Claude Code and Codex
+only (see the [Plugins page](https://pchalasani.github.io/claude-code-tools/getting-started/plugins/)).
+Needs Node.js 22.20 or newer for `npx`:
+
+```bash
+npx skills add pchalasani/claude-code-tools -s voxtype-install
+```
+
 <div align="center">
 
 <table>

{claude_code_tools-1.29.4 → claude_code_tools-1.29.6}/claude_code_tools/__init__.py

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

{claude_code_tools-1.29.4 → claude_code_tools-1.29.6}/claude_code_tools/github_wake.py

@@ -19,8 +19,13 @@ from urllib.parse import urlparse
 
 import click
 
+from claude_code_tools import __version__
 from claude_code_tools.codex_server_process import process_identity
-from claude_code_tools.github_watch_store import IssueWatch, WatchStore
+from claude_code_tools.github_watch_store import (
+    IssueWatch,
+    WatcherStatus,
+    WatchStore,
+)
 from claude_code_tools.issue_reply_delivery import (
     _MAX_MONITOR_MESSAGE_BYTES,
     _MONITOR_ACK,
@@ -31,6 +36,7 @@ from claude_code_tools.issue_reply_delivery import (
 
 _DAEMON_START_SECONDS = 5.0
 _DAEMON_STOP_SECONDS = 5.0
+_DAEMON_REPLACE_SECONDS = 30.0
 _MAX_GH_OUTPUT_BYTES = 1024 * 1024
 
 
@@ -41,6 +47,11 @@ _MAX_GH_OUTPUT_BYTES = 1024 * 1024
 @click.option("--start", is_flag=True, help="Start the shared watcher.")
 @click.option("--stop", is_flag=True, help="Stop the shared watcher.")
 @click.option("--cancel", metavar="WATCH_ID", help="Cancel one pending wakeup.")
+@click.option(
+    "--codex-home",
+    type=click.Path(path_type=Path, exists=True, file_okay=False),
+    help="Codex account directory of this session (default: $CODEX_HOME).",
+)
 @click.option(
     "--claude-monitor",
     is_flag=True,
@@ -53,9 +64,15 @@ def cli(
     start: bool,
     stop: bool,
     cancel: str | None,
+    codex_home: Path | None,
     claude_monitor: bool,
 ) -> None:
-    """Wake this session when ISSUE_URL receives its first future comment."""
+    """Wake this session when ISSUE_URL receives its first future comment.
+
+    In Codex, the reply is delivered with `codex queue` to the session named
+    by CODEX_THREAD_ID. In Claude Code, run with --claude-monitor under the
+    Monitor tool.
+    """
     modes = sum((show_status, start, stop, cancel is not None))
     if modes > 1 or (modes and issue_url is not None) or (modes and claude_monitor):
         raise click.UsageError(
@@ -63,6 +80,8 @@ def cli(
         )
     if as_json and not show_status:
         raise click.UsageError("--json requires --status")
+    if codex_home is not None and (modes or claude_monitor):
+        raise click.UsageError("--codex-home applies only to Codex reply wakeups")
     if show_status:
         _show_status(as_json)
         return
@@ -83,21 +102,20 @@ def cli(
     if claude_monitor:
         _run_claude_monitor(issue_url)
         return
-    _register(issue_url)
+    try:
+        target = codex_target_from_environment(codex_home)
+    except DeliveryConfigurationError as exc:
+        raise click.ClickException(str(exc)) from exc
+    _register(issue_url, target)
 
 
 def _register(
     issue_url: str,
-    target: DeliveryTarget | None = None,
+    target: DeliveryTarget,
     announce: bool = True,
     preserve_on_start_failure: bool = True,
 ) -> IssueWatch:
     """Validate and durably register one existing issue URL."""
-    if target is None:
-        try:
-            target = codex_target_from_environment()
-        except DeliveryConfigurationError as exc:
-            raise click.ClickException(str(exc)) from exc
     repository, issue_number, host = _parse_issue_url(issue_url)
     canonical_url = _verify_issue(repository, issue_number, host)
     store = WatchStore()
@@ -325,19 +343,46 @@ def _stop_watcher(store: WatchStore) -> None:
         return
     assert status is not None
     os.kill(status.pid, signal.SIGTERM)
-    deadline = time.monotonic() + _DAEMON_STOP_SECONDS
+    if not _wait_for_exit(status, _DAEMON_STOP_SECONDS):
+        raise click.ClickException("watcher did not stop after SIGTERM")
+    click.echo("Watcher stopped.")
+
+
+def _replace_watcher(status: WatcherStatus) -> None:
+    """End a watcher of another version, forcing it if a poll keeps it busy.
+
+    Its state is durable, so a forced stop can at most repeat a delivery.
+    """
+    if process_identity(status.pid) != status.process_identity:
+        return
+    os.kill(status.pid, signal.SIGTERM)
+    if _wait_for_exit(status, _DAEMON_REPLACE_SECONDS):
+        return
+    if process_identity(status.pid) == status.process_identity:
+        os.kill(status.pid, signal.SIGKILL)
+    if not _wait_for_exit(status, _DAEMON_STOP_SECONDS):
+        raise RuntimeError("watcher of another version did not exit")
+
+
+def _wait_for_exit(status: WatcherStatus, seconds: float) -> bool:
+    """Wait until the exact recorded watcher process is gone."""
+    deadline = time.monotonic() + seconds
     while time.monotonic() < deadline:
         if process_identity(status.pid) != status.process_identity:
-            click.echo("Watcher stopped.")
-            return
+            return True
         time.sleep(0.05)
-    raise click.ClickException("watcher did not stop after SIGTERM")
+    return False
 
 
-def _ensure_watcher(store: WatchStore) -> bool:
-    """Start one detached watcher and wait for its certified heartbeat."""
-    if _watcher_is_healthy(store.watcher_status()):
-        return False
+def _ensure_watcher(store: WatchStore, replace_other_version: bool = True) -> bool:
+    """Start one detached watcher and wait for its certified heartbeat.
+
+    A healthy watcher left running by another installed version is replaced
+    once, since it may not know the delivery adapter this version records.
+    """
+    status = store.watcher_status()
+    if _watcher_is_healthy(status):
+        return _adopt_watcher(store, status, replace_other_version)
     log = open(store.log_path, "ab", buffering=0)
     try:
         process = subprocess.Popen(
@@ -353,8 +398,9 @@ def _ensure_watcher(store: WatchStore) -> bool:
     deadline = time.monotonic() + _DAEMON_START_SECONDS
     while time.monotonic() < deadline:
         if process.poll() is not None:
-            if _watcher_is_healthy(store.watcher_status()):
-                return False
+            status = store.watcher_status()
+            if _watcher_is_healthy(status):
+                return _adopt_watcher(store, status, replace_other_version)
             raise RuntimeError(f"watcher exited with status {process.returncode}")
         status = store.watcher_status()
         if (
@@ -364,13 +410,29 @@ def _ensure_watcher(store: WatchStore) -> bool:
         ):
             return True
         if _watcher_is_healthy(status):
-            return False
+            return _adopt_watcher(store, status, replace_other_version)
         time.sleep(0.05)
     process.terminate()
     process.wait(timeout=2)
     raise RuntimeError("watcher did not publish a healthy heartbeat")
 
 
+def _adopt_watcher(
+    store: WatchStore,
+    status: WatcherStatus | None,
+    replace_other_version: bool,
+) -> bool:
+    """Reuse a healthy watcher of this version, or replace it once."""
+    if status is not None and status.code_version == __version__:
+        return False
+    if status is None or not replace_other_version:
+        raise RuntimeError(
+            "a watcher from another claude-code-tools version is still running"
+        )
+    _replace_watcher(status)
+    return _ensure_watcher(store, replace_other_version=False)
+
+
 def _watcher_is_healthy(status: object) -> bool:
     """Return whether durable status still identifies its exact process."""
     if status is None:

{claude_code_tools-1.29.4 → claude_code_tools-1.29.6}/claude_code_tools/github_watch_daemon.py

@@ -1,4 +1,4 @@
-"""One shared daemon that wakes Codex when watched GitHub issues get replies."""
+"""One shared daemon that wakes agent sessions when watched issues get replies."""
 
 from __future__ import annotations
 
@@ -17,6 +17,7 @@ from datetime import UTC, datetime, timedelta
 from pathlib import Path
 from types import FrameType
 
+from claude_code_tools import __version__
 from claude_code_tools.codex_server_process import process_identity
 from claude_code_tools.github_watch_store import (
     IssueWatch,
@@ -25,6 +26,7 @@ from claude_code_tools.github_watch_store import (
 )
 from claude_code_tools.issue_reply_delivery import (
     IssueReply,
+    UnsupportedDeliveryTarget,
     deliver_issue_reply,
 )
 
@@ -114,6 +116,7 @@ class GitHubWatchDaemon:
             self.pid,
             self.process_identity,
             self.started_at,
+            __version__,
         )
 
     def _poll_once(self) -> None:
@@ -294,6 +297,9 @@ class GitHubWatchDaemon:
         """Deliver one idempotent reply notification into the origin thread."""
         try:
             deliver_issue_reply(watch, comment)
+        except UnsupportedDeliveryTarget as exc:
+            self.store.mark_failed(watch.watch_id, _diagnostic(exc))
+            return False
         except Exception as exc:
             self.store.mark_retry(watch.watch_id, _diagnostic(exc))
             return False

{claude_code_tools-1.29.4 → claude_code_tools-1.29.6}/claude_code_tools/github_watch_store.py

@@ -50,6 +50,7 @@ class WatcherStatus:
     process_identity: str
     started_at: str
     heartbeat_at: str
+    code_version: str | None = None
 
 
 @dataclass(frozen=True)
@@ -114,6 +115,7 @@ class WatchStore:
         with self._connect() as connection:
             connection.executescript(_SCHEMA)
             _migrate_repository_cursors(connection)
+            _migrate_watcher_status(connection)
 
     @property
     def lock_path(self) -> Path:
@@ -242,6 +244,18 @@ class WatchStore:
                 [(watch_id,) for watch_id in watch_ids],
             )
 
+    def mark_failed(self, watch_id: str, error: str) -> None:
+        """Stop retrying one watch whose delivery can never succeed."""
+        with self._connect() as connection:
+            connection.execute(
+                """
+                UPDATE issue_watches
+                SET status = 'failed', last_error = ?
+                WHERE watch_id = ? AND status IN ('pending', 'retrying')
+                """,
+                (error[:4096], watch_id),
+            )
+
     def cancel(self, watch_id: str) -> bool:
         """Cancel one pending watch by full ID or unambiguous prefix."""
         with self._connect() as connection:
@@ -300,23 +314,32 @@ class WatchStore:
         pid: int,
         process_identity: str,
         started_at: str,
+        code_version: str,
     ) -> None:
-        """Publish ownership and liveness for the lock-holding daemon."""
+        """Publish ownership, liveness, and code version for the daemon."""
         with self._connect() as connection:
             connection.execute(
                 """
                 INSERT INTO watcher_status(
                     singleton, instance_id, pid, process_identity,
-                    started_at, heartbeat_at
-                ) VALUES (1, ?, ?, ?, ?, ?)
+                    started_at, heartbeat_at, code_version
+                ) VALUES (1, ?, ?, ?, ?, ?, ?)
                 ON CONFLICT(singleton) DO UPDATE SET
                     instance_id = excluded.instance_id,
                     pid = excluded.pid,
                     process_identity = excluded.process_identity,
                     started_at = excluded.started_at,
-                    heartbeat_at = excluded.heartbeat_at
+                    heartbeat_at = excluded.heartbeat_at,
+                    code_version = excluded.code_version
                 """,
-                (instance_id, pid, process_identity, started_at, _now()),
+                (
+                    instance_id,
+                    pid,
+                    process_identity,
+                    started_at,
+                    _now(),
+                    code_version,
+                ),
             )
 
     def watcher_status(self) -> WatcherStatus | None:
@@ -333,6 +356,7 @@ class WatchStore:
             process_identity=row["process_identity"],
             started_at=row["started_at"],
             heartbeat_at=row["heartbeat_at"],
+            code_version=row["code_version"],
         )
 
     @contextmanager
@@ -385,6 +409,15 @@ def _migrate_repository_cursors(connection: sqlite3.Connection) -> None:
         connection.execute("ALTER TABLE repository_cursors ADD COLUMN etag TEXT")
 
 
+def _migrate_watcher_status(connection: sqlite3.Connection) -> None:
+    """Record which code version a watcher runs; older watchers leave NULL."""
+    columns = {
+        row["name"] for row in connection.execute("PRAGMA table_info(watcher_status)")
+    }
+    if "code_version" not in columns:
+        connection.execute("ALTER TABLE watcher_status ADD COLUMN code_version TEXT")
+
+
 def _now() -> str:
     """Return a stable UTC timestamp."""
     return datetime.now(UTC).isoformat(timespec="microseconds")

{claude_code_tools-1.29.4 → claude_code_tools-1.29.6}/claude_code_tools/issue_reply_delivery.py

@@ -5,14 +5,12 @@ from __future__ import annotations
 import json
 import os
 import re
+import shutil
 import socket
+import subprocess
 from dataclasses import dataclass
+from pathlib import Path
 
-from claude_code_tools.codex_app_server_rpc import (
-    deliver_thread_message,
-    socket_path_from_endpoint,
-    verify_thread_loaded,
-)
 from claude_code_tools.github_watch_store import IssueWatch
 
 _THREAD_ID = re.compile(
@@ -47,45 +45,100 @@ class DeliveryConfigurationError(RuntimeError):
     """The current agent session cannot receive durable notifications."""
 
 
-def codex_target_from_environment() -> DeliveryTarget:
-    """Preflight and capture the current dynamic Codex target."""
-    thread_id = os.environ.get("CODEX_THREAD_ID", "").strip()
-    endpoint = os.environ.get("CCTOOLS_CODEX_CALLBACK_ENDPOINT", "").strip()
+class UnsupportedDeliveryTarget(DeliveryConfigurationError):
+    """A stored watch names an adapter this version can never deliver to."""
+
+
+def codex_target_from_environment(codex_home: Path | None = None) -> DeliveryTarget:
+    """Preflight and capture the current native Codex session as a queue target.
+
+    Args:
+        codex_home: Codex account directory; defaults to ``$CODEX_HOME`` and
+            then to the one ``~/.codex*`` directory holding this thread.
+
+    Returns:
+        A ``codex-queue-v1`` target naming the thread, account, and executable.
+
+    Raises:
+        DeliveryConfigurationError: This shell is not a usable Codex session.
+    """
+    thread_id = os.environ.get("CODEX_THREAD_ID", "").strip().lower()
     if not _THREAD_ID.fullmatch(thread_id):
         raise DeliveryConfigurationError(
-            "github-wake requires a Codex tool shell launched through "
-            "codex-dynamic"
+            "github-wake requires a Codex session shell (CODEX_THREAD_ID is "
+            "unset); in Claude Code use --claude-monitor"
         )
-    if not endpoint:
-        endpoint = _managed_codex_endpoint(thread_id)
+    home = _codex_home_for_thread(thread_id, codex_home)
+    found = shutil.which("codex")
+    if found is None:
+        raise DeliveryConfigurationError("cannot find the codex executable")
+    # The shared watcher runs elsewhere, so a relative PATH hit must not leak.
+    executable = os.path.abspath(found)
     try:
-        socket_path = socket_path_from_endpoint(endpoint)
-        verify_thread_loaded(socket_path, thread_id)
-    except Exception as exc:
+        completed = subprocess.run(
+            [executable, "queue", "--help"],
+            stdin=subprocess.DEVNULL,
+            capture_output=True,
+            text=True,
+            timeout=30,
+            check=False,
+            env={**os.environ, "CODEX_HOME": str(home)},
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        raise DeliveryConfigurationError(f"cannot run codex: {exc}") from exc
+    if (
+        completed.returncode != 0
+        or "--thread" not in completed.stdout
+        or "--message" not in completed.stdout
+    ):
         raise DeliveryConfigurationError(
-            f"cannot arm a reply notification for this Codex thread: {exc}"
-        ) from exc
+            "the installed codex does not support 'codex queue --thread "
+            "--message'; upgrade Codex"
+        )
     return DeliveryTarget(
-        kind="codex-app-server-v1",
-        payload={"endpoint": endpoint, "threadId": thread_id.lower()},
+        kind="codex-queue-v1",
+        payload={
+            "codexHome": str(home),
+            "executable": executable,
+            "threadId": thread_id,
+        },
     )
 
 
-def _managed_codex_endpoint(thread_id: str) -> str:
-    """Find the unique managed App Server that already owns one thread."""
-    from claude_code_tools.codex_server_resume import resume_server_paths
+def _codex_home_for_thread(
+    thread_id: str,
+    codex_home: Path | None,
+    search_root: Path | None = None,
+) -> Path:
+    """Resolve the Codex account directory that owns one session thread.
 
-    try:
-        paths = resume_server_paths(["resume", thread_id], os.environ, ())
-    except Exception as exc:
-        raise DeliveryConfigurationError(
-            f"cannot locate this thread's managed App Server: {exc}"
-        ) from exc
-    if paths is None:
-        raise DeliveryConfigurationError(
-            "this thread is not loaded by a compatible codex-dynamic App Server"
-        )
-    return paths.endpoint
+    Codex does not export CODEX_HOME to tool shells, so without an explicit
+    directory the unique ``.codex*`` account under ``search_root`` (default:
+    the home directory) holding the rollout is used.
+    """
+    root = search_root or Path.home()
+    explicit = codex_home or (
+        Path(os.environ["CODEX_HOME"]) if os.environ.get("CODEX_HOME") else None
+    )
+    candidates = (
+        [explicit.expanduser()]
+        if explicit is not None
+        else sorted(root.glob(".codex*"))
+    )
+    pattern = f"sessions/*/*/*/rollout-*-{thread_id}.jsonl"
+    owners = {
+        path.resolve()
+        for path in candidates
+        if path.is_dir() and any(path.glob(pattern))
+    }
+    if len(owners) == 1:
+        return owners.pop()
+    searched = ", ".join(str(path) for path in candidates) or str(root)
+    problem = "several account directories" if owners else "no account directory"
+    raise DeliveryConfigurationError(
+        f"{problem} among {searched} holds Codex thread {thread_id}; pass "
+        "--codex-home with this session's account directory"
+    )
 
 
 def deliver_issue_reply(watch: IssueWatch, reply: IssueReply) -> None:
@@ -93,27 +146,47 @@ def deliver_issue_reply(watch: IssueWatch, reply: IssueReply) -> None:
     if watch.target_kind == "claude-monitor-v1":
         _deliver_claude_monitor(watch, reply)
         return
-    if watch.target_kind == "codex-app-server-v1":
-        _deliver_codex(watch, reply)
+    if watch.target_kind == "codex-queue-v1":
+        _deliver_codex_queue(watch, reply)
         return
-    raise DeliveryConfigurationError(
-        f"unsupported issue-reply delivery adapter: {watch.target_kind}"
+    raise UnsupportedDeliveryTarget(
+        f"unsupported issue-reply delivery adapter: {watch.target_kind}; "
+        "re-arm the wakeup with github-wake"
     )
 
 
-def _deliver_codex(watch: IssueWatch, reply: IssueReply) -> None:
-    """Deliver one reply through the Codex App Server."""
-    endpoint = watch.target.get("endpoint")
-    thread_id = watch.target.get("threadId")
-    if not endpoint or not thread_id:
-        raise DeliveryConfigurationError("Codex delivery target is incomplete")
-    client_id = f"github-wake:{watch.watch_id}:{reply.comment_id}"
-    deliver_thread_message(
-        socket_path_from_endpoint(endpoint),
-        thread_id,
-        client_id,
-        _codex_notification_message(watch, reply),
+def _deliver_codex_queue(watch: IssueWatch, reply: IssueReply) -> None:
+    """Queue one reply on the native Codex session and require confirmation."""
+    target = watch.target
+    codex_home = target.get("codexHome")
+    executable = target.get("executable")
+    thread_id = target.get("threadId")
+    if not codex_home or not executable or not thread_id:
+        raise DeliveryConfigurationError("Codex queue target is incomplete")
+    completed = subprocess.run(
+        [
+            executable,
+            "queue",
+            "--thread",
+            thread_id,
+            "--message",
+            _codex_notification_message(watch, reply),
+        ],
+        stdin=subprocess.DEVNULL,
+        capture_output=True,
+        text=True,
+        timeout=60,
+        check=False,
+        env={**os.environ, "CODEX_HOME": codex_home},
+    )
+    if completed.returncode != 0:
+        diagnostic = " ".join(completed.stderr.split())[:1000]
+        raise RuntimeError(f"codex queue failed: {diagnostic}")
+    confirmation = re.compile(
+        r"Queued message [0-9a-f-]{36} for thread " + re.escape(thread_id) + r"\."
     )
+    if not confirmation.search(completed.stdout):
+        raise RuntimeError("codex queue printed no acceptance confirmation")
 
 
 def _deliver_claude_monitor(watch: IssueWatch, reply: IssueReply) -> None:

{claude_code_tools-1.29.4 → claude_code_tools-1.29.6}/claude_code_tools/port_claude_to_codex.py

@@ -514,18 +514,6 @@ def _ensure_leading_user(
         yield msg
 
 
-def _new_assistant_message_id() -> str:
-    """Generate an assistant message id in the modern Codex format.
-
-    Real rollout assistant items carry ids like ``msg_<50 hex chars>``
-    (25 random bytes, hex-encoded, behind a ``msg_`` prefix).
-
-    Returns:
-        A fresh id string matching ``msg_[0-9a-f]{50}``.
-    """
-    return "msg_" + secrets.token_hex(25)
-
-
 def _make_codex_item(
     msg: dict[str, Any], fallback_timestamp: str, turn_id: str
 ) -> dict[str, Any]:
@@ -534,8 +522,11 @@ def _make_codex_item(
     Shapes match real modern rollouts exactly: user messages carry
     ``input_text`` content blocks plus the turn-id metadata
     passthrough; assistant messages carry ``output_text`` content
-    plus the modern assistant payload fields (``id``, ``phase`` and
-    the same turn-id passthrough) that Codex itself writes.
+    plus the modern assistant payload fields (``phase`` and the same
+    turn-id passthrough) that Codex itself writes. Assistant items
+    deliberately omit ``id``: Codex replays item ids to the Responses
+    API, which then looks them up as server-persisted items, and an
+    id that the server never issued fails the turn with HTTP 400.
 
     Args:
         msg: Flattened message dict (role/text/timestamp).
@@ -558,7 +549,6 @@ def _make_codex_item(
     else:
         payload = {
             "type": "message",
-            "id": _new_assistant_message_id(),
             "role": role,
             "content": [
                 {"type": "output_text", "text": msg["text"]}

{claude_code_tools-1.29.4 → claude_code_tools-1.29.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "claude-code-tools"
-version = "1.29.4"
+version = "1.29.6"
 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.4"
+version = "1.29.6"
 tag_format = "v$version"
 version_files = [
     "pyproject.toml:version",