swarph-cli 0.68.0__tar.gz → 0.68.2__tar.gz

{swarph_cli-0.68.0/src/swarph_cli.egg-info → swarph_cli-0.68.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.68.0
+Version: 0.68.2
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.68.0 → swarph_cli-0.68.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.68.0"
+version = "0.68.2"
 description = "The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`."
 readme = "README.md"
 license = { text = "MIT" }

{swarph_cli-0.68.0 → swarph_cli-0.68.2}/src/swarph_cli/__init__.py

@@ -16,6 +16,6 @@ The architecture splits CLI from substrate so:
 
 from __future__ import annotations
 
-__version__ = "0.68.0"
+__version__ = "0.68.2"
 
 __all__ = ["__version__"]

{swarph_cli-0.68.0 → swarph_cli-0.68.2}/src/swarph_cli/commands/hooks.py

@@ -190,17 +190,17 @@ exit 0
 # The bundled codegraph hook (cards #194 + #825). Thin wrapper around
 # `swarph codegraph-hook` so heuristics stay unit-testable.
 #
-# #825: UserPromptSubmit is the load-bearing binding — fires while tool choice
-# is still open. PostToolUse/Bash is kept initially for a shared audit series
-# (drop later if audit shows zero influence). Stop/StopFailure close the
-# counterfactual (subsequent=neither).
+# #825, retired 2026-09-26: UserPromptSubmit / Stop / StopFailure are not
+# installed. The audit showed the prompt side did not steer tool choice
+# (3 codegraph calls in 1,206 displays). PostToolUse/Bash is the binding
+# that stays. install_hook drops the retired events for this command so a
+# later `swarph hooks add` cannot put them back.
 _CODEGRAPH_ON_GREP_SH = r"""#!/bin/sh
 # codegraph-on-grep.sh — swarph bundled Claude Code hook (#194 + #825).
 # swarph-cli-bundle-version: __SWARPH_CLI_VERSION__
 #
-# UserPromptSubmit: coding keywords in the prompt → structural codegraph context
-# before a tool is chosen. PostToolUse/Bash: annotate code greps (shared audit).
-# Stop/StopFailure: record whether the session grepped, called codegraph, or neither.
+# PostToolUse/Bash: annotate code greps. UserPromptSubmit, Stop, and
+# StopFailure are not bound (card #825, retired 2026-09-26).
 # #830: version stamp is substituted at install time — hooks list compares it to
 # the running swarph --version so a binding/code skew is reportable.
 exec swarph codegraph-hook "$@"
@@ -210,10 +210,8 @@ BUILTIN_HOOKS: dict = {
     "codegraph-on-grep": HookBundle(
         name="codegraph-on-grep",
         description=(
-            "On UserPromptSubmit (coding keywords) and PostToolUse/Bash (code "
-            "grep), queries the gateway's structural codegraph and injects "
-            "symbol-level answers. Prompt path steers tool choice; Bash path "
-            "annotates. Audits counterfactual outcomes. Never blocks. Reports "
+            "On PostToolUse/Bash (code grep), queries the gateway's structural "
+            "codegraph and injects symbol-level answers. Never blocks. Reports "
             "an unavailable index LOUDLY rather than as 'no matches'."
         ),
         publisher="swarph-builtin",
@@ -221,13 +219,10 @@ BUILTIN_HOOKS: dict = {
         script_name="codegraph-on-grep.sh",
         script_body=_CODEGRAPH_ON_GREP_SH,
         bindings=(
-            HookBinding("UserPromptSubmit", ""),
             HookBinding("PostToolUse", "Bash"),
-            HookBinding("Stop", ""),
-            HookBinding("StopFailure", ""),
         ),
         handler_events=(
-            "UserPromptSubmit", "PostToolUse", "Stop", "StopFailure",
+            "PostToolUse",
         ),
     ),
     "cell-resilience": HookBundle(
@@ -502,6 +497,49 @@ def _unmerge_hook(settings: dict, event: str, matcher: str, command: str) -> dic
     return settings
 
 
+def _drop_command_outside_bindings(settings: dict, commands, bundle: HookBundle) -> dict:
+    """Remove this bundle's command strings from events it does not declare.
+
+    ``_merge_hook`` only adds. A binding deleted from the bundle would
+    otherwise survive the next install, which is how the retired codegraph
+    prompt-side events came back (card #825). ``commands`` is the install
+    ladder (canonical plus older Windows forms). Other commands on those
+    events are left alone.
+    """
+    keep = {(b.event, b.matcher) for b in bundle.bindings}
+    hooks = settings.get("hooks")
+    if not isinstance(hooks, dict):
+        return settings
+    drop = {v for c in commands for v in _command_variants_for(c)}
+    for event, entries in list(hooks.items()):
+        if not isinstance(entries, list):
+            continue
+        removed = False
+        for entry in list(entries):
+            # A string (or anything else) in an unrelated event is not a
+            # group. Skip it. _unmerge_hook would call .get on it (#825).
+            if not isinstance(entry, dict):
+                continue
+            acts = entry.get("hooks")
+            if not isinstance(acts, list) or (event, entry.get("matcher", "")) in keep:
+                continue
+            kept = [
+                a for a in acts
+                if not (isinstance(a, dict) and a.get("command") in drop)
+            ]
+            # Never rewrite a group that did not hold this command. An empty
+            # hooks list and a matcher-only group stay as they were.
+            if len(kept) == len(acts):
+                continue
+            entry["hooks"] = kept
+            if not kept:
+                entries.remove(entry)
+                removed = True
+        if removed and not entries:
+            del hooks[event]
+    return settings
+
+
 # --------------------------------------------------------------------------- #
 # Local-bundle resolver (T3)
 # --------------------------------------------------------------------------- #
@@ -699,6 +737,11 @@ def install_hook(
     settings = _load_settings(settings_path)
     for b in bundle.bindings:
         settings = _merge_hook(settings, b.event, b.matcher, command)
+    # Drop this command from every event the bundle no longer declares.
+    # Otherwise a retired binding (codegraph UserPromptSubmit/Stop, #825)
+    # stays forever, and the next add puts it back if it was removed by hand.
+    settings = _drop_command_outside_bindings(
+        settings, _installed_command_variants(bundle, hooks_home), bundle)
 
     # ---- write the script (version-stamped), then atomic-save settings ----
     hooks_home_p.mkdir(parents=True, exist_ok=True)
@@ -1058,8 +1101,9 @@ def list_hooks(
 
         name  [installed|partial|available]  trust=builtin  — description
 
-    ``partial`` (#825): at least one binding present but not the full set —
-    the lab-ovh codegraph case (PostToolUse only, UserPromptSubmit/Stop absent).
+    ``partial`` (#825): at least one binding present but not the full set.
+    codegraph-on-grep has a single PostToolUse/Bash binding, so that shape
+    is installed, not partial.
     When installed and the script carries a ``swarph-cli-bundle-version`` stamp
     (#830), a second line reports match / mismatch vs the running package.
     """

{swarph_cli-0.68.0 → swarph_cli-0.68.2}/src/swarph_cli/commands/mesh.py

@@ -1253,6 +1253,38 @@ def _write_cursor_atomic(path: Path, cursor: dict) -> None:
     os.replace(tmp, path)
 
 
+def _persist_wake_stamp(state: "MonitorState") -> None:
+    """Rewrite cursor.json once a wake stamp exists.
+
+    The observation save runs before any sink, so it records last_wake_at
+    while the name is still unknown. Without this second write the file
+    keeps 0.0 after a keystroke (#405).
+    """
+    stamps: list[float] = []
+    for led in state.ledgers.values():
+        raw = led.get("last_wake_at")
+        if raw is None:
+            continue
+        try:
+            stamp = float(raw)
+        except (TypeError, ValueError):
+            continue
+        if stamp > 0:
+            stamps.append(stamp)
+    if not stamps:
+        return
+    newest = max(stamps)
+    previous = state.observed.get("last_wake_at")
+    try:
+        previous_f = float(previous) if previous is not None else 0.0
+    except (TypeError, ValueError):
+        previous_f = 0.0
+    if previous_f == newest:
+        return
+    state.observed["last_wake_at"] = newest
+    _write_cursor_atomic(state.cursor_path, dict(state.cursor))
+
+
 # ─────────────────────────────────────────────────────────────────────────────
 # card #122 — pluggable delivery
 #
@@ -1390,6 +1422,18 @@ class NoneSink(Sink):
         super().__init__("none")
 
 
+def _stamp_wake(led: dict) -> None:
+    """The keystroke, not the delivery report.
+
+    `last_delivery_at` also moves when a standing wake returns True with no
+    keystroke. `last_wake_at` moves only here, beside `last_wake_injected_at`.
+    The name is absent until this runs; 0.0 is not a time.
+    """
+    now = time.time()
+    led["last_wake_at"] = now
+    led["last_wake_injected_at"] = now
+
+
 class TmuxSink(Sink):
     """Poke a tmux pane — the behaviour `mesh sidecar` has always had.
 
@@ -1475,7 +1519,7 @@ class TmuxSink(Sink):
                             return None
                         ok = _tmux_wake(self.target)
                         if ok:
-                            led["last_wake_injected_at"] = time.time()
+                            _stamp_wake(led)
                             return True
                         if ok is None:
                             return None  # human adopted mid-settle: defer
@@ -1504,7 +1548,7 @@ class TmuxSink(Sink):
                             return None
                         ok = _tmux_wake(self.target)
                         if ok:
-                            led["last_wake_injected_at"] = time.time()
+                            _stamp_wake(led)
                             return True
                         if ok is None:
                             return None  # human adopted mid-settle: defer
@@ -1549,7 +1593,8 @@ class TmuxSink(Sink):
                 # The wake text was OBSERVED already sitting in this pane, so
                 # the injection anchor stays valid for this session — nudging
                 # it does not re-anchor (the text predates us).
-                led.setdefault("last_wake_injected_at", time.time())
+                if "last_wake_injected_at" not in led:
+                    _stamp_wake(led)
                 return True
             return False
         if composer == "busy":
@@ -1576,7 +1621,7 @@ class TmuxSink(Sink):
             return None
         if ok:
             led["wake_outstanding"] = True
-            led["last_wake_injected_at"] = time.time()
+            _stamp_wake(led)
             return True
         # False splits by what the pane actually holds: text observably STUCK
         # in the composer -> mark outstanding so the next poll nudges instead
@@ -1898,7 +1943,17 @@ class MonitorState:
                 continue
             led = _new_ledger()
             led["last_delivered_id"] = seed
-            led["last_delivery_at"] = float(self.observed.get("last_wake_at", 0.0))
+            raw = self.observed.get("last_wake_at")
+            try:
+                stamp = float(raw) if raw is not None else 0.0
+            except (TypeError, ValueError):
+                stamp = 0.0
+            led["last_delivery_at"] = stamp
+            # A positive file value is the only wake time the old cursor had.
+            # 0.0 was the unread default, not a measurement — leave the key
+            # absent so a later read is unknown, not "never".
+            if stamp > 0:
+                led["last_wake_at"] = stamp
             self.ledgers[sink.name] = led
 
     def ledger(self, name: str) -> dict:
@@ -2522,6 +2577,10 @@ def _monitor_iteration(state: MonitorState, *, poll_channels: bool = True) -> No
     # A delivery deferred by the idle guard (or failed against a dead sink) must
     # still land even though no NEW mail arrived, so this runs on every poll.
     _monitor_deliver(state)
+    # The observation cursor is written BEFORE delivery, while last_wake_at is
+    # still unknown. A wake that landed this poll has to be written again or
+    # cursor.json keeps the 0.0 default after a real keystroke (#405).
+    _persist_wake_stamp(state)
 
     # MATERIALIZE new ledgers even if nothing moved them. Found by driving the
     # real CLI: a pure `--deliver pull` monitor never writes ledgers.json until
@@ -2783,7 +2842,14 @@ class _LegacyCursorView(MutableMapping):
         if key == "last_msg_id":
             return self._observed.get("last_msg_id", 0)
         if key == "last_wake_at":
-            return float(self._led()["last_delivery_at"])
+            raw = self._led().get("last_wake_at")
+            if raw is None:
+                return None
+            try:
+                stamp = float(raw)
+            except (TypeError, ValueError):
+                return None
+            return stamp if stamp > 0 else None
         if key == "pending_wake":
             return int(self._led()["last_delivered_id"]) < self._observed_id()
         raise KeyError(key)
@@ -2802,7 +2868,11 @@ class _LegacyCursorView(MutableMapping):
                 self._led()["last_delivered_id"] = int(value)
             return
         if key == "last_wake_at":
-            self._led()["last_delivery_at"] = float(value)
+            stamp = float(value)
+            self._led()["last_wake_at"] = stamp
+            # The idle guard reads last_delivery_at. Legacy callers suppress
+            # it by assigning this key; keep that clock in step.
+            self._led()["last_delivery_at"] = stamp
             return
         if key == "pending_wake":
             self._led()["last_delivered_id"] = 0 if value else self._observed_id()

{swarph_cli-0.68.0 → swarph_cli-0.68.2}/src/swarph_cli/commands/schedule.py

@@ -256,7 +256,7 @@ def run_schedule(argv: list) -> int:
         if args.command == "delete":
             return _run_delete(args)
         if args.command == "fire-now":
-            return _run_action(args, "fire-now", "fire-now", "fired")
+            return _run_action(args, "fire-now", "fire-now", "marked")
         parser.error(f"unknown command: {args.command}")
     except RuntimeError as exc:
         print(f"swarph schedule: {exc}", file=sys.stderr)

{swarph_cli-0.68.0 → swarph_cli-0.68.2}/src/swarph_cli/commands/watchdog.py

@@ -792,6 +792,72 @@ def _resolve_send_target(name: str, process_name: str = "claude") -> str:
     return name
 
 
+# How long to wait after Enter before reading the composer. tmux rc==0 means
+# the keys were accepted, not that the pane submitted them (#184).
+_SUBMIT_SETTLE_S = 0.6
+
+
+# Claude's composer is the last ❯ / > line. Everything under the ─── rule is
+# the status footer ("⏵⏵ auto mode on", "✔ Update installed"), which is the
+# last non-empty line of a live pane and is not the composer (#184, #553).
+_COMPOSER_MARKERS = ("❯", ">", "›")
+
+
+def _composed_text(stdout: str) -> Optional[str]:
+    """Text in the composer, with wrapped continuation lines joined.
+
+    None when no composer marker is present. The footer below the rule is
+    not part of the composer.
+    """
+    lines = (stdout or "").splitlines()
+    idx = None
+    for i, ln in enumerate(lines):
+        if ln.strip().startswith(_COMPOSER_MARKERS):
+            idx = i
+    if idx is None:
+        return None
+    first = lines[idx].strip()
+    for marker in _COMPOSER_MARKERS:
+        if first.startswith(marker):
+            first = first[len(marker):].strip()
+            break
+    chunks = [first] if first else []
+    for ln in lines[idx + 1:]:
+        s = ln.strip()
+        if not s:
+            continue
+        if "───" in s or s.startswith("─"):
+            break
+        chunks.append(s)
+    return " ".join(chunks)
+
+
+def _composer_still_holds(target: str, text: str) -> Optional[bool]:
+    """Whether the composer, not the status footer, still contains `text`.
+
+    True = the payload is still composed (accepted, not submitted).
+    False = the composer was read and does not hold it.
+    None = the pane could not be read, or no composer line was found.
+    Callers fail closed on None.
+    """
+    try:
+        result = subprocess.run(
+            ["tmux", "capture-pane", "-p", "-t", target],
+            capture_output=True, timeout=5, text=True,
+            encoding="utf-8", errors="replace",
+        )
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        return None
+    if result.returncode != 0:
+        return None
+    composed = _composed_text(result.stdout or "")
+    if composed is None:
+        return None
+    # A wrap inside a token ('la' / 'b-ovh') joins with a space the payload
+    # does not have. Fold all whitespace on both sides (#184, #555).
+    return re.sub(r"\s+", "", text) in re.sub(r"\s+", "", composed)
+
+
 def _tmux_send_keys(
     name: str, text: str, clear_input: bool = False, process_name: str = "claude"
 ) -> bool:
@@ -805,6 +871,10 @@ def _tmux_send_keys(
     slash-command inject (drop seat-A C2): a prose wake merging into typed
     text is noise, but `/model ...` merging into typed text submits a
     corrupted command.
+
+    Returns True only when a follow-up capture shows the payload has left
+    the composer line. tmux accepting the keys is not delivery (#184). An
+    unreadable pane is False: the wake stays retryable.
     """
     target = _resolve_send_target(name, process_name)
     keys = ["C-u", text, "Enter"] if clear_input else [text, "Enter"]
@@ -813,7 +883,10 @@ def _tmux_send_keys(
             ["tmux", "send-keys", "-t", target, *keys],
             capture_output=True, timeout=5,
         )
-        return result.returncode == 0
+        if result.returncode != 0:
+            return False
+        time.sleep(_SUBMIT_SETTLE_S)
+        return _composer_still_holds(target, text) is False
     except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
         return False
 
@@ -824,12 +897,12 @@ def _dm_wake(
     target_peer: str,
     token: str,
     content: str,
-) -> bool:
-    """A1-DM: send a cross-host wake DM to a stranded peer on another host.
+) -> str | bool:
+    """A1-DM: POST a wake DM. Never raises.
 
-    POSTs a mesh DM (kind=fyi) to ``{gateway}/messages``; the target peer's
-    sidecar/inbox-watcher then wakes it. Pure send action — never raises (an
-    alert/wake path must not crash the watchdog); returns True iff 2xx.
+    Returns ``"accepted"`` when the gateway stores the row (HTTP 2xx) and
+    ``False`` otherwise. ``"accepted"`` is not delivery: this process cannot
+    see the recipient ledger, so it must not return True (#184).
     """
     try:
         body = {
@@ -843,7 +916,9 @@ def _dm_wake(
             body,
             token,
         )
-        return 200 <= status < 300
+        if 200 <= status < 300:
+            return "accepted"
+        return False
     except Exception:
         return False
 
@@ -1113,7 +1188,8 @@ def _notify_peer_event(
         f"(autonomous ladder action; watchdog log on host has the diag)"
     )
     diag["notify_peer"] = peer
-    diag["notify_sent"] = _dm_wake(args.gateway, role, peer, token, content)
+    # 2xx stored the row. It did not deliver it (#184).
+    diag["notify_accepted"] = _dm_wake(args.gateway, role, peer, token, content) == "accepted"
 
 
 def _escalate_a2(
@@ -1259,17 +1335,16 @@ def _dm_wake_scan(
     local session check uses.
 
     T4 — per-peer no-spam cooldown. A peer that stays stale across many ticks
-    is DM'd ONCE per ``--dm-wake-cooldown-sec`` window, not every tick. The
+    is POSTed ONCE per ``--dm-wake-cooldown-sec`` window, not every tick. The
     cooldown state ``{peer: last_wake_epoch}`` is loaded once at scan start;
-    inside the loop a peer is SKIPPED while ``now - last_wake < cooldown_sec``
-    (a cooldown-skip does NOT count as a wake). Only a SUCCESSFUL ``_dm_wake``
-    stamps the cooldown; the state is saved once after the loop.
+    inside the loop a peer is SKIPPED while ``now - last_wake < cooldown_sec``.
+    Only a gateway-accepted POST stamps the cooldown; a rejected POST is
+    retried next tick. The state is saved once after the loop.
 
     ``now_epoch`` defaults to ``_now()`` (injectable for deterministic tests).
 
-    Returns the count of wake DMs that fired successfully THIS tick (0 if none
-    / if ``--dm-wake`` is off / if every stale peer was within cooldown). Never
-    raises (an alert path must not crash the watchdog).
+    Returns 0. A 2xx is the gateway storing the row, not the recipient's
+    ledger, so this scan does not report a fired wake (#184). Never raises.
     """
     if not args.dm_wake:
         return 0
@@ -1300,20 +1375,21 @@ def _dm_wake_scan(
     # T4 — load the per-peer cooldown map once at scan start.
     state = _load_dm_wake_state(state_path)
 
-    fired = 0
+    accepted = 0
     skipped: list[str] = []
     for target in stale:
         last_wake = state.get(target, 0)
         if now_epoch - last_wake < cooldown_sec:
-            # Within cooldown — already DM'd this peer recently. Skip; a
-            # cooldown-skip must NOT count toward the exit-3 wake tally.
+            # Within cooldown — already POSTed this peer recently. Skip.
             skipped.append(target)
             continue
-        if _dm_wake(gateway, self_peer, target, token or "", _DM_WAKE_PROMPT):
-            # Only a SUCCESSFUL DM starts the cooldown — a failed send must
-            # be retried next tick, not suppressed.
+        if _dm_wake(gateway, self_peer, target, token or "", _DM_WAKE_PROMPT) == "accepted":
+            # Gateway stored the row. Stamp the cooldown so the next tick
+            # does not re-POST, but do NOT count it as a fired wake: a 2xx
+            # is not the recipient's ledger (#184). A rejected POST leaves
+            # the cooldown unset so the next tick retries.
             state[target] = now_epoch
-            fired += 1
+            accepted += 1
 
     # Persist the (possibly-updated) cooldown map once after the loop.
     _save_dm_wake_state(state_path, state)
@@ -1325,12 +1401,13 @@ def _dm_wake_scan(
             "self_peer": self_peer,
             "stale_peers": stale,
             "skipped_cooldown": skipped,
-            "wakes_fired": fired,
+            "wakes_accepted": accepted,
+            "wakes_fired": 0,
             "cooldown_sec": cooldown_sec,
         },
         args.verbose,
     )
-    return fired
+    return 0
 
 
 def run_check(args: argparse.Namespace) -> int:
@@ -1338,13 +1415,11 @@ def run_check(args: argparse.Namespace) -> int:
     exit 0/1/2/3/4 — byte-for-byte unchanged), then layers the ``--dm-wake``
     mesh-monitor scan on top.
 
-    Exit precedence (T3): the local own-session action wins. If the local
-    decision took a real action or errored (rc != 0), that code is returned
-    unchanged — the dm-wake scan is an ADDITIONAL mesh-monitor action and
-    must not suppress or be suppressed by the local signal. ONLY when the
-    local decision was a no-op (rc == 0) AND at least one cross-host wake DM
-    fired do we surface exit 3 (A1-DM). When ``--dm-wake`` is off the scan is
-    a pure no-op, so the 0/1/2 behavior is preserved exactly.
+    Exit precedence (T3): the local own-session action wins. The dm-wake
+    scan POSTs and returns 0: a gateway accept is not a delivered wake, so
+    it does not surface exit 3 (#184). Exit 3 remains the local detection
+    error (unreadable cursor). When ``--dm-wake`` is off the scan is a
+    pure no-op.
     """
     log_path = _resolve_log_path(args.log)
     global _HEALTH_EMITTER

{swarph_cli-0.68.0 → swarph_cli-0.68.2}/src/swarph_cli/gateway/server.py

@@ -3117,7 +3117,7 @@ async def scheduled_event_fire_now(name: str,
         c.execute(
             "UPDATE scheduled_events SET last_fired_at = ?, last_status = 'fired', "
             "fire_count = fire_count + 1 WHERE name = ?", (now, name))
-    return {"name": name, "fired": True, "fired_at": now,
+    return {"name": name, "fired": False, "marked": True, "fired_at": now,
             "target_cell": row["target_cell"], "task": row["task"],
             "context_ref": json.loads(row["context_ref"])}
 

{swarph_cli-0.68.0 → swarph_cli-0.68.2}/src/swarph_cli/scripts/wake_watchdog.py

@@ -16,11 +16,28 @@ from typing import Iterable
 GAP_SECONDS = 60
 
 
+def _channel_alive(inbox: str, now: float | None = None) -> bool:
+    """A channel server writes channel_heartbeat.json beside the inbox every 60 s.
+
+    `swarph channel-serve` takes no inbox argument, so no command line names the
+    path; a fresh heartbeat is the only evidence the channel is reading.
+    """
+    hb = Path(inbox).parent / "channel_heartbeat.json"
+    try:
+        ts = float(json.loads(hb.read_text(encoding="utf-8")).get("ts") or 0)
+    except (OSError, ValueError, TypeError, AttributeError):
+        return False
+    return (time.time() if now is None else now) - ts < 180
+
+
 def _watching(inbox: str, cmdlines: Iterable[str]) -> bool:
-    """A reader is tail or dm_notify_filter with the inbox path as its own argument.
+    """A reader is tail or dm_notify_filter with the inbox path as its own argument,
+    or a channel server whose heartbeat is fresh.
 
     A process that merely mentions the path (a prompt, a log line) is not a reader.
     """
+    if _channel_alive(inbox):
+        return True
     for cmd in cmdlines:
         parts = cmd.split()
         if inbox not in parts:
@@ -29,15 +46,6 @@ def _watching(inbox: str, cmdlines: Iterable[str]) -> bool:
             return True
         if any(p.endswith("dm_notify_filter") or p.endswith("dm_notify_filter.py") for p in parts):
             return True
-        if any(p.endswith("swarph_cli.channel") or p.endswith("channel.py") for p in parts):
-            hb = Path(inbox).parent / "channel_heartbeat.json"
-            try:
-                data = json.loads(hb.read_text(encoding="utf-8"))
-                ts = float(data.get("ts") or 0)
-            except (OSError, ValueError, TypeError):
-                continue
-            if time.time() - ts < 180:
-                return True
     return False
 
 

{swarph_cli-0.68.0 → swarph_cli-0.68.2/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.68.0
+Version: 0.68.2
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.68.0 → swarph_cli-0.68.2}/src/swarph_cli.egg-info/SOURCES.txt

@@ -182,6 +182,7 @@ tests/test_132_ensure_monitor_state_dir.py
 tests/test_138_memory_navigate.py
 tests/test_139_tool_probe.py
 tests/test_183_card_anchor.py
+tests/test_184_notify_honesty.py
 tests/test_201_win32_bash_refusal.py
 tests/test_243_onboard_per_peer_token.py
 tests/test_307_task4_ask_reply.py
@@ -227,6 +228,7 @@ tests/test_764_enrich_collapse.py
 tests/test_801_confirm_flow_cli.py
 tests/test_802_stage_history.py
 tests/test_825_codegraph_hook_noise.py
+tests/test_825_install_posttooluse_only.py
 tests/test_825_remaining_cap_shred_bind.py
 tests/test_829_counterfactual_column.py
 tests/test_830_hook_binding_version.py