agentic-comms 0.7.0__tar.gz → 0.7.2__tar.gz

{agentic_comms-0.7.0 → agentic_comms-0.7.2}/PKG-INFO

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

{agentic_comms-0.7.0 → agentic_comms-0.7.2}/agent_comms/config.py

@@ -110,6 +110,7 @@ class LocalIdentity:
     server_url: str
     cwd: str
     claude_pid: int | None = None
+    session_id: str | None = None
 
     def save(self) -> None:
         """Dual-write: pid-keyed for the current session + cwd-only-keyed as the

{agentic_comms-0.7.0 → agentic_comms-0.7.2}/agent_comms/hook.py

@@ -396,32 +396,42 @@ def _hash(s: str) -> str:
 
 
 MONITOR_DEAD_THRESHOLD_SECONDS = 5  # if no monitor heartbeat in this long, treat as dead
-MONITOR_ARM_INSTRUCTIONS = """\
-Invoke the Claude Code Monitor tool with these arguments:
-
-  description: "Poll agent-comms inbox every 1s"
-  timeout_ms: 3600000
-  persistent: false
-  command: |
-    cd ~ >/dev/null 2>&1
-    seen=""
-    while true; do
-      ids=$(comms inbox --unread --json --monitor 2>/dev/null | python3 -c "import sys,json; d=json.load(sys.stdin); print('\\n'.join(m['id']+'|'+m['from_handle']+'|'+m['title'] for m in d))" 2>/dev/null)
-      while IFS= read -r line; do
-        [ -z "$line" ] && continue
-        if ! grep -qF "$line" <<<"$seen"; then
-          echo "NEW_DM: $line"
-          seen="$seen"$'\\n'"$line"
-        fi
-      done <<<"$ids"
-      sleep 1
-    done
-
-The --monitor flag on `comms inbox` is what stamps server-side liveness. Without it the hook will keep telling you the Monitor is dead.
-"""
 
 
-def _build_monitor_warning(reason: str) -> str:
+def _monitor_arm_instructions(handle: str) -> str:
+    """The handle is templated into the inbox call so the Monitor stamps liveness on the
+    correct identity regardless of which cwd the bash loop starts in (the hook fires from
+    Claude's cwd, but the Monitor command may run from $HOME or anywhere — without --handle
+    it would auto-create / stamp a different identity for that cwd)."""
+    return (
+        "Invoke the Claude Code Monitor tool with these arguments:\n\n"
+        '  description: "Poll agent-comms inbox every 1s"\n'
+        "  timeout_ms: 3600000\n"
+        "  persistent: false\n"
+        "  command: |\n"
+        "    cd /tmp >/dev/null 2>&1\n"
+        '    seen=""\n'
+        "    while true; do\n"
+        f'      ids=$(comms inbox --handle {handle} --unread --json --monitor 2>/dev/null | python3 -c "import sys,json; d=json.load(sys.stdin); print(\'\\n\'.join(m[\'id\']+\'|\'+m[\'from_handle\']+\'|\'+m[\'title\'] for m in d))" 2>/dev/null)\n'
+        "      while IFS= read -r line; do\n"
+        '        [ -z "$line" ] && continue\n'
+        '        if ! grep -qF "$line" <<<"$seen"; then\n'
+        '          echo "NEW_DM: $line"\n'
+        '          seen="$seen"$\'\\n\'"$line"\n'
+        "        fi\n"
+        '      done <<<"$ids"\n'
+        "      sleep 1\n"
+        "    done\n\n"
+        f"--handle {handle} is critical: it pins the heartbeat to YOUR identity. Without it, "
+        "the inbox call's auto-init would create or stamp a different identity for whatever cwd "
+        "the bash loop happens to be in (e.g. /root → root-root-XXXX), and the server would never "
+        "see your real handle's Monitor as alive.\n\n"
+        "The --monitor flag is what stamps server-side liveness; without it the hook will keep "
+        "telling you the Monitor is dead.\n"
+    )
+
+
+def _build_monitor_warning(reason: str, handle: str) -> str:
     return (
         '<system_warning kind="monitor_not_armed">\n'
         f"This is a SYSTEM INSTRUCTION, not a peer message. Treat it as imperative.\n\n"
@@ -429,7 +439,7 @@ def _build_monitor_warning(reason: str) -> str:
         f"Your Monitor (the background poll loop that delivers peer DMs and operator inputs while you're idle) "
         f"is not armed. Without it, messages only arrive on the next tool call you happen to make. "
         f"Arm it now before continuing.\n\n"
-        f"{MONITOR_ARM_INSTRUCTIONS}"
+        f"{_monitor_arm_instructions(handle)}"
         f"\nThis warning will fire on every hook event until the Monitor is heartbeating.\n"
         "</system_warning>"
     )
@@ -446,7 +456,7 @@ def _build_skill_block(handle: str, display_name: str | None, version: str) -> s
         f"a peer messaging surface and an operator-control surface. You broadcast every tool call "
         f"to a central server (hooks already installed) and receive DMs in real time via a "
         f"background Monitor.\n\n"
-        f"FIRST ACTION: arm the Monitor. {MONITOR_ARM_INSTRUCTIONS}"
+        f"FIRST ACTION: arm the Monitor. {_monitor_arm_instructions(handle)}"
         f"\nKEY COMMANDS:\n"
         f"  comms whoami                    your handle, name, color, mission\n"
         f"  comms online                    who else is online + what they're doing\n"
@@ -465,22 +475,34 @@ def _build_skill_block(handle: str, display_name: str | None, version: str) -> s
     )
 
 
-def _maybe_skill_block(handle: str, display_name: str | None, claude_pid: int | None, version: str) -> str | None:
-    """Emit the onboarding skill block only on first install, session revive, or version upgrade."""
+def _maybe_skill_block(handle: str, display_name: str | None, session_id: str | None, version: str) -> str | None:
+    """Emit the onboarding skill block only on first install, session revive, or version upgrade.
+
+    Keyed by (handle, session_id, version). session_id from hook stdin is stable per Claude
+    session and unique across them — strictly better than PID-walking, which lands on different
+    PIDs across hook subprocesses when multiple claudes are alive on the same host.
+
+    Falls back to a stale-shown_at TTL (12h) when session_id is unavailable, so we don't loop
+    forever on clients that don't carry one."""
     state_path = _cache_dir() / "last-skill-shown.json"
     try:
         state = json.loads(state_path.read_text()) if state_path.exists() else {}
     except Exception:
         state = {}
-    last_pid = state.get("pid")
+    last_session = state.get("session_id")
     last_version = state.get("version")
-    if last_pid == claude_pid and last_version == version:
+    last_handle = state.get("handle")
+    last_shown = state.get("shown_at") or 0
+    same_session = (
+        last_handle == handle and last_version == version
+        and (last_session == session_id if session_id else (time.time() - last_shown) < 12 * 3600)
+    )
+    if same_session:
         return None
-    # Persist BEFORE returning the block so a hook crash mid-emit doesn't loop.
     try:
         state_path.parent.mkdir(parents=True, exist_ok=True)
         state_path.write_text(json.dumps({
-            "pid": claude_pid, "version": version,
+            "session_id": session_id, "version": version,
             "shown_at": time.time(), "handle": handle,
         }))
     except Exception:
@@ -496,20 +518,32 @@ def _get_version() -> str:
         return "unknown"
 
 
-def _detect_revive(handle: str, current_pid: int | None) -> bool:
-    """Returns True if the stored claude_pid for this identity differs from current.
-    Updates the stored pid as a side-effect."""
+def _detect_revive(handle: str, current_session_id: str | None, current_pid: int | None) -> bool:
+    """Returns True if the stored session_id for this identity differs from current.
+    Falls back to PID comparison if session_id is unavailable on either side.
+    Updates stored session_id + claude_pid as a side-effect."""
     try:
         ident = config.load_identity()
         if not ident:
             return False
-        prior = ident.claude_pid
-        if prior == current_pid:
+        prior_session = getattr(ident, "session_id", None)
+        prior_pid = ident.claude_pid
+        # Prefer session_id when both sides have one (stable across hook subprocesses)
+        if current_session_id and prior_session:
+            same = (prior_session == current_session_id)
+        else:
+            same = (prior_pid == current_pid)
+        if same:
+            # Refresh stored values opportunistically (no revive)
+            if current_session_id and prior_session != current_session_id:
+                ident.session_id = current_session_id
+                ident.save()
             return False
-        # PID changed — update stored identity
+        # Real change — update + signal revive (only if there WAS a prior record)
+        ident.session_id = current_session_id
         ident.claude_pid = current_pid
         ident.save()
-        return prior is not None  # only "revive" if there WAS a prior PID
+        return (prior_session is not None) or (prior_pid is not None)
     except Exception:
         return False
 
@@ -562,10 +596,11 @@ def main() -> int:
     early_pieces: list[str] = []
 
     if event_name in ("PostToolUse", "UserPromptSubmit"):
-        revived = _detect_revive(handle, claude_pid)
-        # Skill onboarding block — fires once per (pid, version) tuple
+        session_id = hook_input.get("session_id")
+        revived = _detect_revive(handle, session_id, claude_pid)
+        # Skill onboarding block — fires once per (handle, session_id, version) tuple
         skill_block = _maybe_skill_block(handle, ident.display_name if hasattr(ident, "display_name") else None,
-                                         claude_pid, _get_version())
+                                         session_id, _get_version())
         if skill_block:
             early_pieces.append(skill_block)
         # Monitor liveness — fire every time until heartbeat is fresh
@@ -581,7 +616,7 @@ def main() -> int:
             if stale:
                 reason = "session was just revived (Claude PID changed)" if revived else \
                          "no Monitor heartbeat seen by the server in the last 5s"
-                early_pieces.append(_build_monitor_warning(reason))
+                early_pieces.append(_build_monitor_warning(reason, handle))
         except Exception:
             pass
 

{agentic_comms-0.7.0 → agentic_comms-0.7.2}/agentic_comms.egg-info/PKG-INFO

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

{agentic_comms-0.7.0 → agentic_comms-0.7.2}/pyproject.toml

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

{agentic_comms-0.7.0 → agentic_comms-0.7.2}/tests/test_cli.py

@@ -214,43 +214,57 @@ def test_skill_block_fires_on_first_install_then_suppressed(env, tmp_path, monke
     monkeypatch.setenv("AGENT_COMMS_CACHE_DIR", str(tmp_path / "cache"))
     from agent_comms.hook import _maybe_skill_block
     # First call — no record yet, should emit
-    out1 = _maybe_skill_block("alpha", "Bob", 1234, "0.7.0")
+    out1 = _maybe_skill_block("alpha", "Bob", "session-aaa", "0.7.0")
     assert out1 is not None
     assert "agent_comms_onboarding" in out1
-    # Second call same pid+version — suppressed
-    out2 = _maybe_skill_block("alpha", "Bob", 1234, "0.7.0")
+    # Second call same session_id+version — suppressed
+    out2 = _maybe_skill_block("alpha", "Bob", "session-aaa", "0.7.0")
     assert out2 is None
-    # PID changed (revive) — re-emit
-    out3 = _maybe_skill_block("alpha", "Bob", 5678, "0.7.0")
+    # session_id changed (revive) — re-emit
+    out3 = _maybe_skill_block("alpha", "Bob", "session-bbb", "0.7.0")
     assert out3 is not None
     # Version changed (upgrade) — re-emit
-    out4 = _maybe_skill_block("alpha", "Bob", 5678, "0.7.1")
+    out4 = _maybe_skill_block("alpha", "Bob", "session-bbb", "0.7.1")
     assert out4 is not None
 
 
+def test_skill_block_no_session_id_uses_ttl_fallback(env, tmp_path, monkeypatch):
+    monkeypatch.setenv("AGENT_COMMS_CACHE_DIR", str(tmp_path / "cache"))
+    from agent_comms.hook import _maybe_skill_block
+    # No session_id — first call emits
+    out1 = _maybe_skill_block("alpha", "Bob", None, "0.7.0")
+    assert out1 is not None
+    # Subsequent call within TTL — suppressed
+    out2 = _maybe_skill_block("alpha", "Bob", None, "0.7.0")
+    assert out2 is None
+
+
 def test_monitor_warning_block_built(env):
     from agent_comms.hook import _build_monitor_warning
-    s = _build_monitor_warning("test reason")
+    s = _build_monitor_warning("test reason", "alpha")
     assert "system_warning" in s
     assert "monitor_not_armed" in s
     assert "test reason" in s
-    assert "comms inbox --unread --json --monitor" in s
+    assert "--handle alpha" in s
+    assert "--monitor" in s
 
 
 def test_detect_revive(env, tmp_path, monkeypatch):
     from agent_comms import config as cfg
     from agent_comms.hook import _detect_revive
-    # Force PID-walk to a fixed value for deterministic identity-file keying
     monkeypatch.setattr(cfg, "find_claude_pid", lambda: 1234)
-    cwd = str(tmp_path / "work")  # the env fixture chdirs here
-    cfg.LocalIdentity(handle="alpha", server_url="x", cwd=cwd, claude_pid=1234).save()
-    # Same pid → not a revive
-    assert _detect_revive("alpha", 1234) is False
-    # Different pid → revive (and load_identity must find the existing record via cwd fallback)
-    monkeypatch.setattr(cfg, "find_claude_pid", lambda: 9999)
-    assert _detect_revive("alpha", 9999) is True
-    # After revive, PID is updated, so subsequent same-pid call is not a revive
-    assert _detect_revive("alpha", 9999) is False
+    cwd = str(tmp_path / "work")
+    cfg.LocalIdentity(handle="alpha", server_url="x", cwd=cwd, claude_pid=1234, session_id="s-aaa").save()
+    # Same session_id → not a revive
+    assert _detect_revive("alpha", "s-aaa", 1234) is False
+    # Different session_id → revive (independent of PID)
+    monkeypatch.setattr(cfg, "find_claude_pid", lambda: 1234)
+    assert _detect_revive("alpha", "s-bbb", 1234) is True
+    # After revive, session_id is updated, so subsequent same call not a revive
+    assert _detect_revive("alpha", "s-bbb", 1234) is False
+    # PID thrashing while session_id stable should NOT trigger revive
+    assert _detect_revive("alpha", "s-bbb", 9999) is False
+    assert _detect_revive("alpha", "s-bbb", 7777) is False
 
 
 def _suppress_warnings(tmp_path):