swarph-cli 0.72.0__tar.gz → 0.72.1__tar.gz

{swarph_cli-0.72.0/src/swarph_cli.egg-info → swarph_cli-0.72.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.0
+Version: 0.72.1
 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.72.0 → swarph_cli-0.72.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.72.0"
+version = "0.72.1"
 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.72.0 → swarph_cli-0.72.1}/src/swarph_cli/__init__.py

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

{swarph_cli-0.72.0 → swarph_cli-0.72.1}/src/swarph_cli/commands/mesh.py

@@ -2302,6 +2302,9 @@ _OPENCODE_WAKE_PROMPT = "check mesh: swarph_dm_unread"
 # Grok's TUI has the same shape (#715, grok 1.0.41): no push channel, so
 # the wake is one line naming the pull tool and no DM body.
 _GROK_WAKE_PROMPT = "check mesh: swarph_dm_unread"
+# Muse 1.4.1 has no push channel either. The wake names the pull tool,
+# same text the grok and opencode sinks inject.
+_MUSE_WAKE_PROMPT = "check mesh: swarph_dm_unread"
 # A finished turn keeps its ▣ header and adds a duration.
 # Short turns read `· 3.3s` (drop-on-meta-edge, 1.18.33, card #961 post
 # 54557). A longer idle turn reads `· 3m 4s` (opencode pane, 2026-09-29
@@ -2439,7 +2442,7 @@ def _only_wake_text(content: str) -> bool:
     human's line.
     """
     rest = content
-    for prompt in (_GROK_WAKE_PROMPT, _OPENCODE_WAKE_PROMPT, _WAKE_PROMPT):
+    for prompt in (_MUSE_WAKE_PROMPT, _GROK_WAKE_PROMPT, _OPENCODE_WAKE_PROMPT, _WAKE_PROMPT):
         rest = rest.replace(prompt, "")
     return rest.strip() == ""
 
@@ -2611,8 +2614,13 @@ def _is_muse_rule(line: str) -> bool:
 
 
 def _is_muse_status(line: str) -> bool:
-    """The status under the lower rule. Measured: ``muse-spark-… · … · YOLO``."""
-    return "muse-spark" in line and "·" in line
+    """A status row under the lower rule.
+
+    Measured muse-spark is ``model · effort · path · YOLO``. An echo
+    provider is ``echo · ~/x · YOLO``. The anchor is two or more `` · ``
+    separators, not the model name. A model switch must not blind the sink.
+    """
+    return line.count(" · ") >= 2
 
 
 def _is_muse_composer_row(lines: list[str], index: int) -> bool:
@@ -2853,6 +2861,8 @@ def _wake_prompt_for(lines: Optional[list[str]]) -> str:
         return _GROK_WAKE_PROMPT
     if lines and _is_opencode_pane(lines):
         return _OPENCODE_WAKE_PROMPT
+    if lines and _is_muse_pane(lines):
+        return _MUSE_WAKE_PROMPT
     return _WAKE_PROMPT
 
 

{swarph_cli-0.72.0 → swarph_cli-0.72.1}/src/swarph_cli/commands/spawn.py

@@ -393,14 +393,21 @@ _CLAUDE_CHANNELS = frozenset({"allowlisted", "dev"})
 _MUSE_CHANNELS = frozenset({"ingress"})
 
 
-def _resolve_channel(cell: Cell) -> str:
-    """Effective channel mode: $SWARPH_CHANNEL wins (incl. "off"), else the
-    cell.yaml `channel` field (kept by swarph-shared in the forward-compat
-    `extra` bag), else "" (absent). Never launches anything; callers validate.
-    """
-    env_mode = os.environ.get("SWARPH_CHANNEL") or ""
-    if env_mode:
-        return env_mode
+# Providers whose spawn consumes $SWARPH_CHANNEL. Anything else ignores an
+# inherited value (a Claude cell's shell carries allowlisted; spawning grok
+# from it must not refuse). Measured 2026-10-01: 0.72.0 blamed cell.yaml
+# for that env and exited on grok-researcher.yaml, which has no channel field.
+_ENV_CHANNEL_PROVIDERS = frozenset({"claude", "muse"})
+
+
+def _channel_where(source: str) -> str:
+    """Name the place the mode came from. An env value must not read as cell.yaml."""
+    if source == "env":
+        return "SWARPH_CHANNEL"
+    return "cell.yaml: 'channel'"
+
+
+def _field_channel(cell: Cell) -> str:
     extra = getattr(cell, "extra", None) or {}
     value = extra.get("channel", "") if isinstance(extra, dict) else ""
     if value is None:
@@ -413,64 +420,88 @@ def _resolve_channel(cell: Cell) -> str:
     return value
 
 
-def _channel_marketplace_dir() -> Path:
+def _resolve_channel(cell: Cell) -> tuple[str, str]:
+    """Effective channel mode and where it came from.
+
+    ``$SWARPH_CHANNEL`` wins (incl. "off") only for providers that support
+    it: claude (allowlisted/dev/off) and muse (ingress/off). Other providers
+    ignore the inherited env, as before 0.72.0, and the cell.yaml field is
+    still read. Returns ``(mode, source)`` with source ``env``, ``cell.yaml``,
+    or ``""``. Never launches anything; callers validate.
+    """
+    env_mode = os.environ.get("SWARPH_CHANNEL") or ""
+    provider = getattr(cell, "provider", None)
+    # No provider attribute: the stamp probes construct a name-only cell.
+    # Those are claude-shaped; the env still applies.
+    if env_mode and (provider is None or provider in _ENV_CHANNEL_PROVIDERS):
+        return env_mode, "env"
+    field = _field_channel(cell)
+    return field, ("cell.yaml" if field else "")
+
+
+def _channel_marketplace_dir(source: str = "cell.yaml") -> Path:
     """Install location of the `swarph` Claude marketplace (the allowlist).
 
     Resolved through ~/.claude/plugins/known_marketplaces.json, the same
     registry claude reads — never a second hardcoded copy that drifts.
+    ``source`` names env vs cell.yaml so a missing registry is not blamed
+    on the file when the mode came from ``$SWARPH_CHANNEL``.
     """
+    where = _channel_where(source)
     registry = Path.home() / ".claude" / "plugins" / "known_marketplaces.json"
     try:
         data = json.loads(registry.read_text(encoding="utf-8"))
     except (OSError, ValueError) as exc:
         raise CellError(
-            f"cell.yaml: channel 'allowlisted' needs the swarph marketplace, "
+            f"{where} 'allowlisted' needs the swarph marketplace, "
             f"but its registry is unreadable: {registry} ({exc})."
         ) from exc
     try:
         location = data["swarph"]["installLocation"]
     except (KeyError, TypeError) as exc:
         raise CellError(
-            f"cell.yaml: channel 'allowlisted' needs the swarph marketplace, "
+            f"{where} 'allowlisted' needs the swarph marketplace, "
             f"but it is not registered in {registry}."
         ) from exc
     path = Path(location)
     if not path.is_dir():
         raise CellError(
-            f"cell.yaml: channel 'allowlisted' needs the swarph marketplace "
+            f"{where} 'allowlisted' needs the swarph marketplace "
             f"at {path}, which is not a directory."
         )
     return path
 
 
-def _validate_channel(cell: Cell, mode: str) -> str:
+def _validate_channel(cell: Cell, mode: str, source: str = "cell.yaml") -> str:
     """Fail closed on any channel mode the provider cannot consume.
 
     Returns the mode unchanged. "" and "off" are valid everywhere (no-op).
-    Raises CellError naming the field (and the file, for a missing
-    marketplace) so the operator fixes config, never debugs a deaf cell.
+    Raises CellError naming the source (``SWARPH_CHANNEL`` or the cell.yaml
+    field) and the file, for a missing marketplace, so the operator fixes
+    config, never debugs a deaf cell.
     """
     if mode in ("", "off"):
         return mode
+    where = _channel_where(source)
     provider = cell.provider
     if provider == "claude":
         if mode not in _CLAUDE_CHANNELS:
             raise CellError(
-                f"cell.yaml: 'channel' {mode!r} is not valid for provider "
+                f"{where} {mode!r} is not valid for provider "
                 f"'claude'. Valid values: {sorted(_CLAUDE_CHANNELS | {'off'})}."
             )
         if mode == "allowlisted":
-            _channel_marketplace_dir()
+            _channel_marketplace_dir(source)
         return mode
     if provider == "muse":
         if mode not in _MUSE_CHANNELS:
             raise CellError(
-                f"cell.yaml: 'channel' {mode!r} is not valid for provider "
+                f"{where} {mode!r} is not valid for provider "
                 f"'muse'. Valid values: {sorted(_MUSE_CHANNELS | {'off'})}."
             )
         return mode
     raise CellError(
-        f"cell.yaml: 'channel' {mode!r} is only valid for providers "
+        f"{where} {mode!r} is only valid for providers "
         f"'claude' and 'muse'; provider is {provider!r}."
     )
 
@@ -498,7 +529,8 @@ def _build_claude_argv(
             argv.extend(["--append-system-prompt", starter])
 
     argv.extend(passthrough)
-    mode = _validate_channel(cell, _resolve_channel(cell))
+    mode, source = _resolve_channel(cell)
+    mode = _validate_channel(cell, mode, source)
     if mode == "allowlisted":
         argv.extend(["--channels", "plugin:swarph@swarph"])
     elif mode == "dev":
@@ -545,7 +577,7 @@ def _spawn_env_base(cell: Cell) -> dict[str, str]:
     env = scrub_env_for_subprocess()
     env["SWARPH_SPAWN"] = "1"
     env["SWARPH_SELF"] = cell.name
-    mode = _resolve_channel(cell)
+    mode, _source = _resolve_channel(cell)
     # NOTE: the marketplace/validity gate lives in _validate_channel, which
     # _build_claude_argv (and the muse env builder) run. This base stays a
     # pure reflection of the resolved mode so every provider's env agrees.
@@ -587,7 +619,8 @@ def _muse_env(cell: Cell) -> dict[str, str]:
     run_spawn choke point; the mode read here agrees with it by construction.
     """
     env = _claude_env(cell)
-    if _resolve_channel(cell) == "ingress":
+    mode, _source = _resolve_channel(cell)
+    if mode == "ingress":
         env["MUSE_EXPERIMENTAL_EXTERNAL_AGENT_INGRESS"] = "on"
     return env
 
@@ -3308,7 +3341,8 @@ def run_spawn(argv: Optional[list[str]] = None) -> int:
     # must not leave a minted sidecar behind). One choke point for every
     # provider; builders below see only validated modes.
     try:
-        _validate_channel(cell, _resolve_channel(cell))
+        mode, source = _resolve_channel(cell)
+        _validate_channel(cell, mode, source)
     except CellError as exc:
         print(f"swarph spawn: {exc}", file=sys.stderr)
         return 1

{swarph_cli-0.72.0 → swarph_cli-0.72.1/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.0
+Version: 0.72.1
 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.72.0 → swarph_cli-0.72.1}/tests/test_1006_board_publisher.py

@@ -309,3 +309,40 @@ def test_live_entry_drops_a_closed_row_and_a_failed_read_sends_nothing(tmp_path,
     assert all(argv[:3] != ["swarph", "mesh", "send"] for argv in calls)
     assert all("inbox" not in argv for argv in calls)
     assert not hasattr(pub, "commander_replies")
+
+
+def test_in_session_marker_sets_the_flag_and_strips_the_title():
+    """An accept starting [commander][in-session] Re-login... builds
+    in_session=true and a title without the marker. A plain [commander]
+    row with no deploy or hard-gate words stays false. On main the title
+    keeps [in-session] and the flag stays false.
+    """
+    pub = _load()
+    listing = (ROOT / "tests" / "fixtures" / "session-board" / "listagents-lab.txt").read_text(encoding="utf-8")
+    rows = pub.commander_rows([
+        {
+            "id": 5,
+            "holder": "droplet",
+            "card_id": 1006,
+            "state": "open",
+            "accept": "[commander][in-session] Re-login to the board | PASS=the commander re-logs",
+        },
+        {
+            "id": 6,
+            "holder": "droplet",
+            "card_id": 1006,
+            "state": "open",
+            "accept": "[commander] Note the weather today | PASS=nothing",
+        },
+    ])
+    board = pub.build_board.build(listing, rows)
+    questions = [
+        q for sess in board["sessions"] if sess["name"] == "droplet" for q in sess["questions"]
+    ]
+    marked = next(q for q in questions if q["obligation"] == 5)
+    plain = next(q for q in questions if q["obligation"] == 6)
+    assert marked["in_session"] is True
+    assert marked["title"] == "Re-login to the board"
+    assert "[in-session]" not in marked["title"]
+    assert "[commander]" not in marked["title"]
+    assert plain["in_session"] is False

{swarph_cli-0.72.0 → swarph_cli-0.72.1}/tests/test_1013_spawn_channel.py

@@ -19,11 +19,11 @@ from swarph_cli.cell import SCHEMA_VERSION_V1
 from swarph_cli.commands.spawn import run_spawn
 
 
-def _cell_yaml(tmp_path: Path, provider: str, channel=None) -> Path:
+def _cell_yaml(tmp_path: Path, provider: str, channel=None, name: str = "probe-cell") -> Path:
     payload = {
         "schema_version": SCHEMA_VERSION_V1,
-        "name": "probe-cell",
-        "role": "probe-cell",
+        "name": name,
+        "role": name,
         "cwd": str(tmp_path),
         "provider": provider,
     }
@@ -175,3 +175,72 @@ def test_allowlisted_missing_allowlist_errors(tmp_path, monkeypatch, capsys):
     assert rc != 0
     assert "known_marketplaces.json" in err or "marketplace" in err.lower()
     assert str(home) in err or "swarph" in err
+
+
+def test_inherited_env_is_ignored_for_grok_and_kept_for_claude(tmp_path, monkeypatch, capsys):
+    """0.72.0 regression. A Claude shell's SWARPH_CHANNEL must not refuse grok.
+
+    (1) allowlisted + grok, no channel field: exit 0, no channel flag, no
+        SWARPH_CHANNEL_CELL. (2) the same env + claude: --channels, as before.
+    On main, (1) exits non-zero blaming cell.yaml.
+    """
+    _registry(tmp_path, monkeypatch, with_swarph=True)
+    monkeypatch.setenv("SWARPH_CHANNEL", "allowlisted")
+    monkeypatch.setenv("SWARPH_CHANNEL_CELL", "lab-ovh")
+    (tmp_path / "grok").mkdir()
+    grok = _cell_yaml(tmp_path / "grok", "grok")
+    rc, argv, env_added = _print(tmp_path, grok, capsys)
+    assert rc == 0
+    assert argv is not None
+    assert not any("channel" in a for a in argv)
+    assert "SWARPH_CHANNEL_CELL" not in env_added
+    assert "lab-ovh" not in json.dumps(env_added)
+
+    (tmp_path / "claude").mkdir()
+    claude = _cell_yaml(tmp_path / "claude", "claude")
+    rc, argv, env_added = _print(tmp_path, claude, capsys)
+    assert rc == 0
+    assert "--channels" in argv and "plugin:swarph@swarph" in argv
+    assert env_added.get("SWARPH_CHANNEL_CELL") == "probe-cell"
+
+
+def test_grok_field_errors_name_cell_yaml(tmp_path, monkeypatch, capsys):
+    """(3) a grok cell.yaml channel: allowlisted is still a hard error, and
+    the text names cell.yaml rather than the env var. Fails on main only if
+    the message stops naming the file; the refusal itself is already there.
+    """
+    _registry(tmp_path, monkeypatch, with_swarph=True)
+    monkeypatch.delenv("SWARPH_CHANNEL", raising=False)
+    p = _cell_yaml(tmp_path, "grok", channel="allowlisted")
+    rc = run_spawn(["--cell", str(p), "--print-resolved"])
+    _, err = capsys.readouterr()
+    assert rc != 0
+    assert "cell.yaml" in err
+    assert "SWARPH_CHANNEL" not in err
+
+
+def test_bogus_env_on_claude_names_the_env_var(tmp_path, monkeypatch, capsys):
+    """(4) SWARPH_CHANNEL=bogus on a claude cell exits non-zero naming the
+    env var. On main the same refusal blames cell.yaml.
+    """
+    _registry(tmp_path, monkeypatch, with_swarph=True)
+    monkeypatch.setenv("SWARPH_CHANNEL", "bogus")
+    p = _cell_yaml(tmp_path, "claude")
+    rc = run_spawn(["--cell", str(p), "--print-resolved"])
+    _, err = capsys.readouterr()
+    assert rc != 0
+    assert "SWARPH_CHANNEL" in err
+
+
+def test_parent_channel_cell_does_not_reach_a_different_cell(tmp_path, monkeypatch, capsys):
+    """(5) SWARPH_CHANNEL_CELL=lab-ovh inherited while spawning science-claude
+    (the live cell is channel allowlisted) yields that cell's own name.
+    """
+    _registry(tmp_path, monkeypatch, with_swarph=True)
+    monkeypatch.delenv("SWARPH_CHANNEL", raising=False)
+    monkeypatch.setenv("SWARPH_CHANNEL_CELL", "lab-ovh")
+    p = _cell_yaml(tmp_path, "claude", channel="allowlisted", name="science-claude")
+    rc, _argv, env_added = _print(tmp_path, p, capsys)
+    assert rc == 0
+    assert env_added.get("SWARPH_CHANNEL_CELL") == "science-claude"
+

{swarph_cli-0.72.0 → swarph_cli-0.72.1}/tests/test_1017_muse_tui.py

@@ -56,10 +56,26 @@ def test_idle_empty_muse_composer_is_woken_once(monkeypatch):
     assert mesh.TmuxSink("muse-1017-sac").deliver(_State(led), [], 1) is True
     keys = _keys(calls)
     assert keys == [
-        ["tmux", "send-keys", "-t", "muse-1017-sac", "-l", mesh._WAKE_PROMPT],
+        ["tmux", "send-keys", "-t", "muse-1017-sac", "-l", mesh._MUSE_WAKE_PROMPT],
         ["tmux", "send-keys", "-t", "muse-1017-sac", "Enter"],
     ]
     assert led["wake_outstanding"] is True
+    assert "swarph_dm_unread" in mesh._MUSE_WAKE_PROMPT
+
+
+def test_echo_model_label_is_still_muse_and_wakes_once(monkeypatch):
+    """Drop #927: a status row that is not muse-spark must still be muse.
+    Fails on main, where the status check requires the model name."""
+    pane = _pane("idle.txt").replace("muse-spark-1.3-contributor", "echo")
+    pane = pane.replace("echo · high · /tmp/muse-1017-ws · YOLO", "echo · ~/x · YOLO")
+    assert "muse-spark" not in pane
+    assert mesh._bottom_tui(pane.splitlines()) == "muse"
+    calls = _record(monkeypatch, pane)
+    assert mesh.TmuxSink("muse-1017-sac").deliver(_State({}), [], 1) is True
+    sent = _keys(calls)
+    assert sent[0][-1] == mesh._MUSE_WAKE_PROMPT
+    assert "swarph_dm_unread" in sent[0][-1]
+    assert sent[1:] == [["tmux", "send-keys", "-t", "muse-1017-sac", "Enter"]]
 
 
 def test_muse_draft_defers_with_a_named_reason(monkeypatch, tmp_path, capsys):