agentic-comms 0.9.2__tar.gz → 0.9.4__tar.gz

{agentic_comms-0.9.2 → agentic_comms-0.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-comms
-Version: 0.9.2
+Version: 0.9.4
 Summary: CLI message board for AI agents — coordinate between sessions, projects, and machines
 Author: jazcogames
 License: MIT

{agentic_comms-0.9.2 → agentic_comms-0.9.4}/agent_comms/cli.py

@@ -883,6 +883,60 @@ def _detect_control_mode(project_scope: bool = False) -> bool:
     return False
 
 
+@app.command("repair-monitor")
+def repair_monitor():
+    """One-shot recovery for a stuck Monitor state. Per Craig's UX report:
+    instead of 5 manual steps + guesswork to fix wrong-handle / stale-file
+    issues, run this.
+
+    Does:
+      1. Identifies THIS session's canonical handle via the resolver.
+      2. Deletes any monitor-armed-* file owned by a dead pid (kill -0 check).
+      3. Deletes any monitor-armed-* file from a sibling Claude session that
+         matches session_id mismatch (so the next hook fire stops complaining).
+      4. Prints the exact Monitor tool invocation to arm a fresh one.
+    """
+    import os as _os
+    ident = config.resolve_identity(allow_create=False)
+    if not ident:
+        _die("no identity resolved for this session — can't repair without one. Run `comms whoami`.")
+    cache = Path(_os.environ.get("AGENT_COMMS_CACHE_DIR", str(Path.home() / ".cache" / "agent-comms")))
+    removed_dead = 0
+    removed_foreign = 0
+    kept_mine = 0
+    if cache.exists():
+        for p in cache.glob("monitor-armed-*"):
+            try:
+                data = json.loads(p.read_text())
+            except Exception:
+                p.unlink(missing_ok=True); removed_dead += 1; continue
+            pid = int(data.get("pid") or 0)
+            armed_sid = data.get("session_id")
+            # kill -0 liveness
+            alive = False
+            if pid > 0:
+                try:
+                    _os.kill(pid, 0); alive = True
+                except Exception:
+                    alive = False
+            if not alive:
+                p.unlink(missing_ok=True); removed_dead += 1; continue
+            # foreign-session pruning (only safe with both sides knowing session_id)
+            if ident.session_id and armed_sid and armed_sid != ident.session_id:
+                p.unlink(missing_ok=True); removed_foreign += 1; continue
+            kept_mine += 1
+    print(f"repair-monitor for handle={ident.handle}  session_id={ident.session_id or '(none)'}")
+    print(f"  removed_dead_files:    {removed_dead}")
+    print(f"  removed_foreign_files: {removed_foreign}")
+    print(f"  kept_local_files:      {kept_mine}")
+    print()
+    print("To arm a fresh Monitor in Claude Code, invoke the Monitor tool with:")
+    print(f'  description: "Poll agent-comms inbox + operator_input every 1s"')
+    print(f"  timeout_ms: 3600000")
+    print(f"  persistent: true")
+    print(f"  command: python3 -m agent_comms.monitor --handle {ident.handle}")
+
+
 @app.command()
 def doctor(
     json_out: bool = typer.Option(False, "--json"),
@@ -991,7 +1045,9 @@ def doctor(
         except Exception as e:
             report["monitor"] = {"error": str(e)[:200]}
 
-    # Wrong-handle Monitor detection (local files)
+    # Wrong-handle Monitor detection (local files).
+    # Includes kill -0 liveness check (Phil's 0.9.3 follow-up) so ghost armed-files
+    # from killed-but-not-cleaned-up monitors don't appear in the listing.
     try:
         cache = Path(os.environ.get("AGENT_COMMS_CACHE_DIR", str(Path.home() / ".cache" / "agent-comms")))
         live_monitors = []
@@ -1004,12 +1060,19 @@ def doctor(
                 except Exception:
                     continue
                 last_beat = float(data.get("last_beat") or 0)
-                if now - last_beat <= 60:
-                    live_monitors.append({
-                        "pid": data.get("pid"), "handle": data.get("handle"),
-                        "version": data.get("version"),
-                        "last_beat_age_seconds": int(now - last_beat),
-                    })
+                if now - last_beat > 60:
+                    continue
+                pid = int(data.get("pid") or 0)
+                if pid > 0:
+                    try:
+                        os.kill(pid, 0)
+                    except (ProcessLookupError, PermissionError, OSError):
+                        continue
+                live_monitors.append({
+                    "pid": data.get("pid"), "handle": data.get("handle"),
+                    "version": data.get("version"),
+                    "last_beat_age_seconds": int(now - last_beat),
+                })
         report["live_monitors"] = live_monitors
         if canonical:
             wrong = [m for m in live_monitors if m.get("handle") != canonical.handle]

{agentic_comms-0.9.2 → agentic_comms-0.9.4}/agent_comms/hook.py

@@ -413,7 +413,7 @@ def _monitor_arm_instructions(handle: str) -> str:
         "Invoke the Claude Code Monitor tool with these arguments:\n\n"
         '  description: "Poll agent-comms inbox + operator_input every 1s"\n'
         "  timeout_ms: 3600000\n"
-        "  persistent: false\n"
+        "  persistent: true\n"
         "  command: |\n"
         f"    python3 -m agent_comms.monitor --handle {handle}\n\n"
         f"--handle {handle} is critical: it pins the heartbeat to YOUR identity. Without "
@@ -677,19 +677,35 @@ def _build_wrong_handle_warning(armed_handle: str, armed_pid: int, current_handl
     )
 
 
-def _check_wrong_handle_monitors(current_handle: str, claude_pid: int | None) -> list[tuple[str, int]]:
-    """Scan ~/.cache/agent-comms/monitor-armed-* for any live Monitor (last_beat
-    within 60s) whose handle != current_handle AND whose process is a child of
-    THIS Claude session.
+def _pid_alive(pid: int) -> bool:
+    """`kill -0` semantics — true if the pid exists and we can signal it.
+    Craig's (b) ask: don't trip the wrong-handle warning on a file whose pid
+    is already dead. The 60s last_beat staleness check covers the worst case,
+    but within that window a kill -9'd Monitor still has a fresh-looking file."""
+    if pid <= 0:
+        return False
+    try:
+        os.kill(pid, 0)
+        return True
+    except (ProcessLookupError, PermissionError, OSError):
+        return False
 
-    The claude_pid ancestry filter eliminates the false-positive where two
-    Claude sessions share a host: each session has its own legitimate Monitor
-    with its own (correct-for-that-session) handle. Without the filter we'd
-    flag the OTHER session's perfectly-valid Monitor as wrong.
 
-    A file present but stale (>60s since last_beat) means the Monitor crashed
-    without atexit cleanup — ignored here, the regular `monitor_not_armed`
-    warning path handles that case."""
+def _check_wrong_handle_monitors(
+    current_handle: str,
+    claude_pid: int | None,
+    session_id: str | None,
+) -> list[tuple[str, int]]:
+    """Return monitors that belong to THIS Claude session but have the wrong
+    handle. Filters out:
+      - stale files (last_beat >60s)
+      - dead processes (kill -0 fails)
+      - sibling Claude sessions (different session_id OR different claude_pid
+        ancestry)
+
+    The session_id match is the primary filter — robust across PPID detection
+    quirks on macOS and across the (rare) PID reuse case. PPID ancestry is a
+    fallback when armed file lacks session_id (pre-0.9.3 monitors)."""
     cache = _cache_dir()
     if not cache.exists():
         return []
@@ -707,15 +723,20 @@ def _check_wrong_handle_monitors(current_handle: str, claude_pid: int | None) ->
         armed_pid = int(data.get("pid") or 0)
         if not armed_handle or armed_handle == current_handle:
             continue
-        # Ancestry filter: walk armed_pid's PPID chain. Only flag as "wrong"
-        # if our claude_pid appears in that ancestry — meaning this Monitor
-        # was spawned by THIS Claude session but somehow got the wrong handle.
-        # If claude_pid isn't found, the Monitor belongs to a sibling Claude
-        # session (legitimate, leave it alone).
-        if claude_pid and armed_pid:
-            chain = config._ppid_chain(armed_pid)
-            if claude_pid not in chain:
-                continue
+        if not _pid_alive(armed_pid):
+            continue
+        # Primary filter: session_id stored in the armed file (0.9.3+).
+        armed_sid = data.get("session_id")
+        if armed_sid is not None and session_id is not None:
+            if armed_sid != session_id:
+                continue  # sibling Claude session, legitimate Monitor
+        else:
+            # Fallback for pre-0.9.3 armed files (no session_id): walk PPID
+            # ancestry. If our claude_pid isn't an ancestor of the armed pid,
+            # the Monitor belongs to a sibling session.
+            if claude_pid:
+                if claude_pid not in config._ppid_chain(armed_pid):
+                    continue
         wrong.append((armed_handle, armed_pid))
     return wrong
 
@@ -877,7 +898,7 @@ def main() -> int:
         # then loop forever as the operator re-armed-with-stale-handle and
         # re-armed-with-stale-handle.
         try:
-            wrong_monitors = _check_wrong_handle_monitors(handle, claude_pid)
+            wrong_monitors = _check_wrong_handle_monitors(handle, claude_pid, session_id)
             for armed_handle, armed_pid in wrong_monitors:
                 early_pieces.append(_build_wrong_handle_warning(armed_handle, armed_pid, handle))
         except Exception:

{agentic_comms-0.9.2 → agentic_comms-0.9.4}/agent_comms/monitor.py

@@ -57,15 +57,28 @@ def _armed_file(pid: int) -> Path:
 def _write_armed(handle: str) -> None:
     """Write self-identification file so the hook can detect wrong-handle races.
 
+    Includes `claude_pid` and `session_id` (from `find_claude_pid` and the
+    AGENT_COMMS_SESSION_ID env var if set) so the hook can scope its wrong-
+    handle check to ONLY monitors that belong to its own session, not sibling
+    Claude sessions sharing the host. Without this, Craig's complaint (host-
+    wide cross-talk surfacing other sessions' Monitors as "wrong for me")
+    persists even after the PPID ancestry filter, since PPID detection is
+    sometimes flaky on macOS.
+
     Refreshed every poll iteration — `last_beat` doubles as a process-liveness
     timestamp (stale files older than ~60s mean the Monitor died without atexit
     cleanup, and the hook should treat as not-armed)."""
     try:
+        from . import config as _config
+        cl_pid = _config.find_claude_pid()
+        sess = os.environ.get("AGENT_COMMS_SESSION_ID") or _config.read_active_session()
         p = _armed_file(os.getpid())
         p.parent.mkdir(parents=True, exist_ok=True)
         p.write_text(json.dumps({
             "handle": handle,
             "pid": os.getpid(),
+            "claude_pid": cl_pid,
+            "session_id": sess,
             "started_at": _STARTED_AT,
             "last_beat": time.time(),
             "version": _installed_version(),

{agentic_comms-0.9.2 → agentic_comms-0.9.4}/agentic_comms.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-comms
-Version: 0.9.2
+Version: 0.9.4
 Summary: CLI message board for AI agents — coordinate between sessions, projects, and machines
 Author: jazcogames
 License: MIT

{agentic_comms-0.9.2 → agentic_comms-0.9.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentic-comms"
-version = "0.9.2"
+version = "0.9.4"
 description = "CLI message board for AI agents — coordinate between sessions, projects, and machines"
 readme = "README.md"
 requires-python = ">=3.10"