vibego 1.0.2__py3-none-any.whl → 1.0.10__py3-none-any.whl

scripts/master_healthcheck.py

@@ -1,137 +1,65 @@
 #!/usr/bin/env python3
-"""Master Post-startup health check script.
+"""Master post-startup health check.
 
-Process:
-1. Wait for a startup flag to appear in the master log.
-2. Call MasterManager to start the specified worker (default hyphavibebotbackend).
-3. Automatically discover the worker's chat_id(Prioritize the state file, then read the latest log).
-4. Send a probe message to the chat through the Telegram Bot API to confirm that the sending is successful.
-5. If any step fails, an exception is thrown and an attempt is made to notify the administrator.
-
-Note: This script will not automatically retry the restart and will only return a non-zero exit code for processing by the outer script.
+This lightweight variant only verifies that the master process has emitted the
+readiness marker in its log file. Worker bootstrap and Telegram probes are no
+longer executed because master restart confirmation is now limited to the
+controller process itself.
 """
 from __future__ import annotations
 
 import argparse
-import asyncio
 import json
 import os
-import re
 import sys
 import time
 from pathlib import Path
-from typing import Optional
-from urllib.error import URLError, HTTPError
 from urllib.request import Request, urlopen
 
-# Import the configuration and tools in master and reuse the project parsing logic
+# Make sure the master module can be imported from the repository root
 ROOT_DIR = Path(__file__).resolve().parent.parent
 ROOT_DIR_STR = str(ROOT_DIR)
 if ROOT_DIR_STR not in sys.path:
-    # Make sure the master module can be imported from the repository root
     sys.path.insert(0, ROOT_DIR_STR)
 
 import master  # type: ignore
-from project_repository import ProjectRepository
+
 DEFAULT_MASTER_LOG = master.LOG_ROOT_PATH / "vibe.log"
 DEFAULT_TIMEOUT_MASTER = 60.0
-DEFAULT_TIMEOUT_PROBE = 15.0
-PROBE_TEXT = "hello"
-REPOSITORY = ProjectRepository(master.CONFIG_DB_PATH, master.CONFIG_PATH)
-
-
-def _load_project(project_id: str) -> master.ProjectConfig:
-    """Get the project configuration based on the slug or bot name, and list the options on failure."""
-
-    record = REPOSITORY.get_by_slug(project_id)
-    if record is None:
-        record = REPOSITORY.get_by_bot_name(project_id)
-    if record is None:
-        available = [r.project_slug for r in REPOSITORY.list_projects()]
-        raise RuntimeError(f"No items found {project_id}, Optional items: {available}")
-    return master.ProjectConfig.from_dict(record.to_dict())
+MASTER_READY_MARKER = "Master Started, listening for administrator commands."
 
 
 def _wait_for_log_flag(path: Path, pattern: str, timeout: float) -> None:
-    """Waits for a specific mark in the log within the timeout period."""
+    """Poll the master log until the readiness marker is detected or timeout."""
 
     deadline = time.monotonic() + timeout
-    position = 0
+    if path.exists():
+        position = path.stat().st_size
+        initialized = True
+    else:
+        position = 0
+        initialized = False
     while time.monotonic() < deadline:
         if path.exists():
-            if position == 0:
-                position = path.stat().st_size
+            if not initialized:
+                position = 0
+                initialized = True
             with path.open("r", encoding="utf-8", errors="ignore") as fh:
                 fh.seek(position)
                 while time.monotonic() < deadline:
                     line = fh.readline()
                     if not line:
                         time.sleep(0.5)
-                        continue
+                        break
                     position = fh.tell()
                     if pattern in line:
                         return
         time.sleep(0.5)
-    raise TimeoutError(f"exist {timeout:.0f} No log markers detected in seconds: {pattern}")
-
-
-def _extract_chat_id_from_logs(log_path: Path) -> Optional[int]:
-    """Find the most recent chat from the log file in reverse order_id."""
-
-    if not log_path.exists():
-        return None
-    pattern = re.compile(r"chat=(-?\d+)")
-    try:
-        lines = log_path.read_text(encoding="utf-8", errors="ignore").splitlines()
-    except Exception:
-        return None
-    for line in reversed(lines[-200:]):  # Reverse search for recent records
-        match = pattern.search(line)
-        if match:
-            try:
-                return int(match.group(1))
-            except ValueError:
-                continue
-    return None
-
-
-def _ensure_chat_id(cfg: master.ProjectConfig, manager: master.MasterManager) -> int:
-    """Make sure the task is assigned chat_id, Backfill from log and write back to state if necessary."""
-
-    state = manager.state_store.data.get(cfg.project_slug)
-    if state and state.chat_id:
-        return int(state.chat_id)
-    # Fall back to log search
-    log_dir = master.LOG_ROOT_PATH / (cfg.default_model.lower()) / cfg.project_slug
-    chat_id = _extract_chat_id_from_logs(log_dir / "run_bot.log")
-    if chat_id is None:
-        raise RuntimeError(
-            "Unable to get chat automatically_id, Please manually have a conversation with the bot to write the state/log"
-        )
-    # will discover chat_id Write back the state for easy reuse next time
-    manager.state_store.update(cfg.project_slug, chat_id=chat_id)
-    return chat_id
-
-
-def _send_probe(bot_token: str, chat_id: int, text: str, timeout: float) -> None:
-    """Send a probe message to the specified chat to verify that the Telegram API is available."""
-
-    url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
-    payload = json.dumps({"chat_id": chat_id, "text": text, "disable_notification": True}).encode("utf-8")
-    request = Request(url, data=payload, headers={"Content-Type": "application/json"}, method="POST")
-    try:
-        with urlopen(request, timeout=timeout) as resp:
-            data = json.loads(resp.read().decode("utf-8"))
-    except HTTPError as exc:  # pragma: no cover - Thrown when network exception occurs
-        raise RuntimeError(f"Failed to send probe message, HTTP {exc.code}: {exc.reason}") from exc
-    except URLError as exc:  # pragma: no cover - Thrown when network exception occurs
-        raise RuntimeError(f"Failed to send probe message: {exc}") from exc
-    if not data.get("ok"):
-        raise RuntimeError(f"Failed to send probe message: {data}")
+    raise TimeoutError(f"No log markers detected within {timeout:.0f}s: {pattern}")
 
 
 def _format_admin_notice(reason: str) -> str:
-    """Generate alarm text to notify the administrator."""
+    """Compose the notification text for administrator alerts."""
 
     return (
         "Master Restart health check failed\n"
@@ -141,7 +69,7 @@ def _format_admin_notice(reason: str) -> str:
 
 
 def _notify_admins(reason: str) -> None:
-    """If the master token is available, the failure reason is broadcast to the administrator list."""
+    """Broadcast the failure reason to administrators if the master token exists."""
 
     master_token = os.environ.get("MASTER_BOT_TOKEN")
     if not master_token:
@@ -163,58 +91,30 @@ def _notify_admins(reason: str) -> None:
             continue
 
 
-def _ensure_worker(cfg: master.ProjectConfig) -> master.MasterManager:
-    """Starts the specified project worker and returns the temporarily constructed MasterManager."""
-
-    records = REPOSITORY.list_projects()
-    configs = [master.ProjectConfig.from_dict(record.to_dict()) for record in records]
-    state_store = master.StateStore(
-        master.STATE_PATH, {item.project_slug: item for item in configs}
-    )
-    manager = master.MasterManager(configs, state_store=state_store)
-
-    async def _run() -> None:
-        """The coroutine performs the actual stop/start process."""
-        # Make sure to stop the old instance first(If it existsexist)
-        try:
-            await manager.stop_worker(cfg)
-        except Exception:
-            pass
-        await manager.run_worker(cfg)
-
-    asyncio.run(_run())
-    return manager
-
-
 def main() -> int:
-    """Command line entry, performs master health check and returns exit code."""
-
-    parser = argparse.ArgumentParser(description="Master Post-launch health check")
-    parser.add_argument("--project", default="hyphavibebotbackend", help="Project slug or bot name")
-    parser.add_argument("--master-log", default=str(DEFAULT_MASTER_LOG), help="master Log path")
-    parser.add_argument("--master-timeout", type=float, default=DEFAULT_TIMEOUT_MASTER, help="master Log wait timeout (Second)")
-    parser.add_argument("--probe-timeout", type=float, default=DEFAULT_TIMEOUT_PROBE, help="Telegram Probe timeout (Second)")
+    """Command line entry point, only validates master readiness."""
+
+    parser = argparse.ArgumentParser(description="Master post-launch health check (master only)")
+    parser.add_argument("--master-log", default=str(DEFAULT_MASTER_LOG), help="Master log path")
+    parser.add_argument(
+        "--master-timeout",
+        type=float,
+        default=DEFAULT_TIMEOUT_MASTER,
+        help="Master log wait timeout (seconds)",
+    )
     args = parser.parse_args()
 
-    project_id = master._sanitize_slug(args.project)
     master_log = Path(args.master_log)
 
     try:
-        _wait_for_log_flag(master_log, "Master Started, listening for administrator commands.", args.master_timeout)
-        cfg = _load_project(project_id)
-        manager = _ensure_worker(cfg)
-        chat_id = _ensure_chat_id(cfg, manager)
-        _send_probe(cfg.bot_token, chat_id, PROBE_TEXT, args.probe_timeout)
+        _wait_for_log_flag(master_log, MASTER_READY_MARKER, args.master_timeout)
     except Exception as exc:
         reason = str(exc)
         _notify_admins(reason)
         print(f"[healthcheck] fail: {reason}", file=sys.stderr)
         return 1
     else:
-        print(
-            "[healthcheck] success: master ready,"
-            f"worker={cfg.display_name} Startup completed, chat_id={chat_id}, Probe message sent"
-        )
+        print("[healthcheck] success: master ready, worker checks skipped by configuration")
         return 0
 
 

scripts/requirements.txt

@@ -2,3 +2,4 @@ aiogram>=3.0.0,<4.0.0
 aiohttp-socks>=0.10.0
 aiosqlite>=0.19.0
 markdown-it-py>=3.0.0,<4.0.0
+watchdog>=4.0.0

scripts/run_bot.sh

@@ -90,6 +90,7 @@ LOG_DIR="$(log_dir_for "$MODEL" "$PROJECT_NAME")"
 MODEL_LOG="$LOG_DIR/model.log"
 RUN_LOG="$LOG_DIR/run_bot.log"
 POINTER_FILE="$LOG_DIR/${MODEL_POINTER_BASENAME:-current_session.txt}"
+LOCK_FILE="${SESSION_LOCK_FILE:-$LOG_DIR/${MODEL_POINTER_LOCK_BASENAME:-session_lock.json}}"
 TMUX_SESSION="$(tmux_session_for "$PROJECT_NAME")"
 
 expand_model_workdir() {
@@ -167,6 +168,8 @@ export MODEL_SESSION_ROOT
 export MODEL_SESSION_GLOB
 export SESSION_POINTER_FILE="$POINTER_FILE"
 export CODEX_SESSION_FILE_PATH="$POINTER_FILE"
+export SESSION_LOCK_FILE="$LOCK_FILE"
+export SESSION_LOCK_FILE_PATH="$LOCK_FILE"
 export TMUX_SESSION="$TMUX_SESSION"
 export TMUX_LOG="$MODEL_LOG"
 export PROJECT_NAME="$PROJECT_NAME"

scripts/session_pointer_watch.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+"""Capture the session JSONL path generated after a worker launch and lock it.
+
+This helper watches the Codex/Claude session directory after the tmux worker
+starts. The first rollout file that matches the configured working directory is
+recorded into both the pointer file (used by the worker for streaming) and a
+dedicated lock file so subsequent bindings never drift to another CLI session.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import sys
+import time
+from datetime import datetime, timezone
+from fnmatch import fnmatch
+from pathlib import Path
+from threading import Event, Lock
+from typing import Iterable, Optional
+
+try:
+    from watchdog.events import FileSystemEvent, FileSystemEventHandler
+    from watchdog.observers import Observer
+except Exception:  # pragma: no cover - watchdog is an optional dependency fallback
+    Observer = None
+    FileSystemEventHandler = object  # type: ignore[assignment]
+
+
+log = logging.getLogger("session_pointer_watch")
+
+
+def _resolve(path: str) -> Path:
+    return Path(path).expanduser().resolve()
+
+
+def _read_session_cwd(path: Path) -> Optional[str]:
+    """Read first JSON line and return payload.cwd when available."""
+
+    try:
+        with path.open("r", encoding="utf-8", errors="ignore") as fh:
+            first_line = fh.readline()
+    except OSError:
+        return None
+    if not first_line:
+        return None
+    try:
+        data = json.loads(first_line)
+    except json.JSONDecodeError:
+        return None
+    payload = data.get("payload")
+    if isinstance(payload, dict):
+        raw = payload.get("cwd")
+        if isinstance(raw, str):
+            return raw
+    return None
+
+
+def _iter_candidate_files(roots: Iterable[Path], glob: str) -> Iterable[Path]:
+    for root in roots:
+        if not root.exists():
+            continue
+        try:
+            real_root = root.resolve()
+        except OSError:
+            real_root = root
+        yield from real_root.glob(f"**/{glob}")
+
+
+class _RolloutCapture(FileSystemEventHandler):
+    """Handle filesystem events and pick the first rollout that matches criteria."""
+
+    def __init__(
+        self,
+        *,
+        pattern: str,
+        baseline: set[str],
+        start_wall: float,
+        start_monotonic: float,
+        target_cwd: Optional[str],
+        timeout: float,
+        poll_interval: float,
+    ) -> None:
+        self._pattern = pattern
+        self._baseline = baseline
+        self._start_wall = start_wall
+        self._target_cwd = target_cwd
+        self._deadline = start_monotonic + timeout
+        self._poll_interval = poll_interval
+        self._chosen: Optional[Path] = None
+        self._event = Event()
+        self._lock = Lock()
+
+    def _consider(self, candidate: Path) -> None:
+        if candidate.is_dir():
+            return
+        name = candidate.name
+        if not fnmatch(name, self._pattern):
+            return
+        try:
+            real_path = candidate.resolve()
+        except OSError:
+            real_path = candidate
+        real_key = str(real_path)
+        if real_key in self._baseline:
+            return
+        try:
+            stat = real_path.stat()
+        except OSError:
+            return
+        if stat.st_mtime + 0.01 < self._start_wall:
+            # Ignore historical files.
+            return
+
+        if self._target_cwd:
+            # Wait until the JSON header is flushed and matches our CWD.
+            deadline = time.monotonic() + self._poll_interval * 10
+            while time.monotonic() < deadline:
+                cwd = _read_session_cwd(real_path)
+                if cwd is None:
+                    time.sleep(self._poll_interval)
+                    continue
+                if cwd == self._target_cwd:
+                    break
+                log.debug("Skip rollout with mismatched cwd=%s", cwd)
+                return
+        with self._lock:
+            if self._chosen is None:
+                self._chosen = real_path
+                self._event.set()
+
+    # The following methods are only called when watchdog is available.
+    def on_created(self, event: FileSystemEvent) -> None:  # type: ignore[override]
+        if getattr(event, "is_directory", False):
+            return
+        self._consider(Path(event.src_path))
+
+    def on_moved(self, event: FileSystemEvent) -> None:  # type: ignore[override]
+        if getattr(event, "is_directory", False):
+            return
+        self._consider(Path(event.dest_path))
+
+    def poll_until_found(self, roots: Iterable[Path]) -> Optional[Path]:
+        while time.monotonic() < self._deadline:
+            remaining = self._deadline - time.monotonic()
+            if remaining <= 0:
+                break
+            wait_time = min(self._poll_interval, remaining)
+            if self._event.wait(timeout=wait_time):
+                break
+            for candidate in _iter_candidate_files(roots, self._pattern):
+                self._consider(candidate)
+                if self._event.is_set():
+                    break
+            if self._event.is_set():
+                break
+        return self._chosen
+
+
+def _write_pointer(pointer: Path, session_path: Path) -> None:
+    pointer.parent.mkdir(parents=True, exist_ok=True)
+    pointer.write_text(str(session_path), encoding="utf-8")
+
+
+def _write_lock(lock_file: Path, *, session_path: Path, tmux_session: str, project: str, workdir: str, method: str) -> None:
+    payload = {
+        "session_path": str(session_path),
+        "captured_at": datetime.now(timezone.utc).isoformat(),
+        "tmux_session": tmux_session,
+        "project": project,
+        "workdir": workdir,
+        "method": method,
+    }
+    lock_file.parent.mkdir(parents=True, exist_ok=True)
+    lock_file.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+
+
+def main(argv: Optional[list[str]] = None) -> int:
+    parser = argparse.ArgumentParser(description="Capture newly created Codex/Claude rollout JSONL and write pointer+lock files.")
+    parser.add_argument("--pointer", required=True, help="Path to current_session.txt pointer file")
+    parser.add_argument("--lock", required=True, help="Path to persistent lock metadata JSON")
+    parser.add_argument("--session-root", required=False, help="Primary sessions root directory")
+    parser.add_argument("--additional-root", action="append", default=[], help="Extra directories to monitor for rollouts")
+    parser.add_argument("--glob", default="rollout-*.jsonl", help="Glob pattern for rollout files")
+    parser.add_argument("--workdir", default="", help="Model working directory, used to filter sessions")
+    parser.add_argument("--tmux-session", default="", help="tmux session name for diagnostics")
+    parser.add_argument("--project", default="", help="Project slug for diagnostics")
+    parser.add_argument("--timeout", type=float, default=180.0, help="Maximum seconds to wait for a new rollout")
+    parser.add_argument("--poll", type=float, default=0.5, help="Polling interval when watchdog is unavailable")
+    args = parser.parse_args(argv)
+
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+
+    pointer_path = _resolve(args.pointer)
+    lock_path = _resolve(args.lock)
+    roots: list[Path] = []
+    if args.session_root:
+        roots.append(_resolve(args.session_root))
+    pointer_parent = pointer_path.parent
+    if pointer_parent not in roots:
+        roots.append(pointer_parent)
+    for raw in args.additional_root:
+        resolved = _resolve(raw)
+        if resolved not in roots:
+            roots.append(resolved)
+
+    baseline = {str(path.resolve()) for path in _iter_candidate_files(roots, args.glob)}
+    start_wall = time.time()
+    start_monotonic = time.monotonic()
+
+    capture = _RolloutCapture(
+        pattern=args.glob,
+        baseline=baseline,
+        start_wall=start_wall,
+        start_monotonic=start_monotonic,
+        target_cwd=args.workdir or None,
+        timeout=args.timeout,
+        poll_interval=max(args.poll, 0.1),
+    )
+
+    observer: Optional[Observer] = None
+    method = "watchdog"
+    if Observer is not None:
+        observer = Observer()
+        for root in roots:
+            if root.exists():
+                observer.schedule(capture, str(root), recursive=True)
+        observer.start()
+    else:  # pragma: no cover - watchdog is optional
+        log.warning("watchdog not available, falling back to polling")
+        method = "polling"
+
+    try:
+        session_path = capture.poll_until_found(roots)
+    finally:
+        if observer is not None:
+            observer.stop()
+            observer.join(timeout=5)
+
+    if session_path is None:
+        log.error(
+            "Failed to detect rollout file within timeout %.1fs (tmux session=%s, project=%s)",
+            args.timeout,
+            args.tmux_session or "-",
+            args.project or "-",
+        )
+        return 1
+
+    _write_pointer(pointer_path, session_path)
+    _write_lock(
+        lock_path,
+        session_path=session_path,
+        tmux_session=args.tmux_session,
+        project=args.project,
+        workdir=args.workdir,
+        method=method,
+    )
+
+    log.info("Recorded session pointer -> %s", session_path)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/start.sh

@@ -118,8 +118,9 @@ ensure_codex_installed() {
 ensure_codex_installed
 
 select_python_binary() {
-  # Choose to meet CPython <=3.12 interpreter, disabled by default 3.13(pydantic-core There is no compatible wheel in the pipx base environment)
+  # Select a compatible CPython version; defaults accept 3.9-3.14 and can be overridden via env variables.
   local allow_py313="${VIBEGO_ALLOW_PY313:-}"
+  local supported_max_minor="${VIBEGO_MAX_MINOR:-14}"
   local candidates=()
   local chosen=""
   local name
@@ -152,18 +153,24 @@ select_python_binary() {
     if [[ -n "${VIBEGO_PYTHON:-}" && "$name" == "$VIBEGO_PYTHON" ]]; then
       explicit_override=1
     fi
-    if [[ "$minor" =~ ^[0-9]+$ ]] && (( minor == 13 )) && [[ "$allow_py313" != "1" ]] && (( explicit_override == 0 )); then
-      log_line "jump over ${name} (Version ${version_raw}): Python 3 is disabled by default.13, Configurable VIBEGO_ALLOW_PY313=1 cover" >&2
-      continue
+    if [[ "$minor" =~ ^[0-9]+$ ]] && (( minor == 13 )) && (( explicit_override == 0 )); then
+      if [[ "$allow_py313" == "0" ]]; then
+        log_line "Skip ${name} (version ${version_raw}): disabled explicitly by VIBEGO_ALLOW_PY313=0" >&2
+        continue
+      fi
+      log_line "Detected ${name} (version ${version_raw}): Python 3.13 accepted by default; use VIBEGO_ALLOW_PY313=1 to prefer or 0 to disable" >&2
     fi
-    if [[ "$minor" =~ ^[0-9]+$ ]] && (( minor > 13 )); then
-      log_line "jump over ${name} (Version ${version_raw}): higher than 3.13" >&2
+    if [[ "$minor" =~ ^[0-9]+$ ]] && (( minor > supported_max_minor )) && (( explicit_override == 0 )); then
+      log_line "Skip ${name} (version ${version_raw}): above supported ceiling 3.${supported_max_minor}; override with VIBEGO_MAX_MINOR if needed" >&2
       continue
     fi
     if [[ "$minor" =~ ^[0-9]+$ ]] && (( minor < 9 )); then
       log_line "jump over ${name} (Version ${version_raw}): less than 3.9, May be missing official wheels" >&2
       continue
     fi
+    if [[ "$minor" =~ ^[0-9]+$ ]] && (( minor >= 14 )); then
+      log_line "Detected ${name} (version ${version_raw}): ensure dependencies support this Python version" >&2
+    fi
     chosen="$name"
     log_line "Using the Python interpreter:${chosen} (Version ${version_raw})" >&2
     break
@@ -438,13 +445,13 @@ fi
 log_info "master Started in background, PID=$MASTER_PID, Log writing ${LOG_FILE}"
 
 # Health check: wait for master to come online and verify key workers
-log_info "Start health check..."
+log_info "Start master readiness check..."
 HEALTHCHECK_START=$(date +%s)
 
-if python scripts/master_healthcheck.py --project hyphavibebotbackend; then
+if python scripts/master_healthcheck.py --master-log "$LOG_FILE"; then
   HEALTHCHECK_END=$(date +%s)
   HEALTHCHECK_DURATION=$((HEALTHCHECK_END - HEALTHCHECK_START))
-  log_info "OK: Master health check passed (elapsed ${HEALTHCHECK_DURATION}s)"
+  log_info "OK: Master readiness confirmed (elapsed ${HEALTHCHECK_DURATION}s)"
 else
   HEALTHCHECK_END=$(date +%s)
   HEALTHCHECK_DURATION=$((HEALTHCHECK_END - HEALTHCHECK_START))

scripts/start_tmux_codex.sh

@@ -18,6 +18,11 @@ MODEL_WORKDIR="${MODEL_WORKDIR:-$ROOT_DIR}"
 MODEL_SESSION_ROOT="${MODEL_SESSION_ROOT:-${CODEX_SESSION_ROOT:-$HOME/.codex/sessions}}"
 MODEL_SESSION_GLOB="${MODEL_SESSION_GLOB:-rollout-*.jsonl}"
 SESSION_POINTER_FILE="${SESSION_POINTER_FILE:-$LOG_ROOT/${MODEL_NAME:-codex}/${PROJECT_NAME:-project}/current_session.txt}"
+SESSION_LOCK_FILE="${SESSION_LOCK_FILE:-${SESSION_POINTER_FILE%.txt}.lock.json}"
+SESSION_CAPTURE_TIMEOUT="${SESSION_CAPTURE_TIMEOUT:-180}"
+SESSION_CAPTURE_POLL_INTERVAL="${SESSION_CAPTURE_POLL_INTERVAL:-0.5}"
+# Ensure optional CODEX session root is always defined even under `set -u`
+: "${CODEX_SESSIONS_ROOT:=}"
 
 # Avoid oh-my-zsh popping up update prompts in non-interactive environments
 export DISABLE_UPDATE_PROMPT="${DISABLE_UPDATE_PROMPT:-true}"
@@ -67,6 +72,7 @@ MODEL_SESSION_ROOT=$(expand_path "$MODEL_SESSION_ROOT")
 SESSION_POINTER_FILE=$(expand_path "$SESSION_POINTER_FILE")
 ensure_dir "$(dirname "$LOG_PATH")"
 ensure_dir "$(dirname "$SESSION_POINTER_FILE")"
+ensure_dir "$(dirname "$SESSION_LOCK_FILE")"
 
 run_tmux() {
   if (( DRY_RUN )); then
@@ -143,5 +149,24 @@ if (( DRY_RUN )); then
 fi
 
 : > "$SESSION_POINTER_FILE"
+rm -f "$SESSION_LOCK_FILE"
+
+if (( ! DRY_RUN )); then
+  WATCH_ARGS=("$PYTHON_EXEC" "$ROOT_DIR/scripts/session_pointer_watch.py" "--pointer" "$SESSION_POINTER_FILE" "--lock" "$SESSION_LOCK_FILE" "--glob" "$MODEL_SESSION_GLOB" "--workdir" "$MODEL_WORKDIR" "--tmux-session" "$SESSION_NAME" "--project" "${PROJECT_NAME:-}")
+  if [[ -n "$MODEL_SESSION_ROOT" ]]; then
+    WATCH_ARGS+=("--session-root" "$MODEL_SESSION_ROOT")
+  fi
+  if [[ -n "$CODEX_SESSIONS_ROOT" ]]; then
+    WATCH_ARGS+=("--additional-root" "$CODEX_SESSIONS_ROOT")
+  fi
+  WATCH_ARGS+=("--additional-root" "$(dirname "$SESSION_POINTER_FILE")")
+  WATCH_ARGS+=("--additional-root" "$(dirname "$SESSION_POINTER_FILE")/sessions")
+  WATCH_ARGS+=("--timeout" "$SESSION_CAPTURE_TIMEOUT")
+  WATCH_ARGS+=("--poll" "$SESSION_CAPTURE_POLL_INTERVAL")
+  if ! "${WATCH_ARGS[@]}"; then
+    echo "Failed to capture Codex/Claude session log for tmux session '$SESSION_NAME'. Please check CLI startup output." >&2
+    exit 1
+  fi
+fi
 
 exit 0