swarph-cli 0.60.0__tar.gz → 0.62.0__tar.gz

{swarph_cli-0.60.0/src/swarph_cli.egg-info → swarph_cli-0.62.0}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.60.0"
+version = "0.62.0"
 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" }
@@ -146,6 +146,7 @@ swarph_cli = ["systemd/*.service", "systemd/*.timer", "systemd/*.default",
               "systemd/*.path",
               "scripts/*.sh", "scripts/*.ps1", "guide/*.md",
               "payloads/postcompact/*.sh", "payloads/postcompact/*.cmd",
+              "payloads/opencode/*.js",
     "skills/*/SKILL.md", "skills/*/LICENSE"]
 # v0.15: ship the bundled mesh-gateway schema so `swarph gateway serve`
 # can apply it at startup via MESH_SCHEMA_PATH (defaults next to server.py).

{swarph_cli-0.60.0 → swarph_cli-0.62.0}/src/swarph_cli/__init__.py

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

{swarph_cli-0.60.0 → swarph_cli-0.62.0}/src/swarph_cli/cell.py

@@ -66,7 +66,7 @@ _validate_uuid = validate_uuid_str  # historical helper name
 # ONE swarph-cli release, and entry into swarph_shared.VALID_PROVIDERS only in a
 # later one. spawn.py's guard is `VALID_PROVIDERS ⊆ MEMBRANES`, so this direction
 # is inert while the reverse raises at import for every fresh install (#247).
-CLI_ENABLED_PROVIDERS = VALID_PROVIDERS | {"muse", "cursor"}
+CLI_ENABLED_PROVIDERS = VALID_PROVIDERS | {"muse", "cursor", "opencode"}
 
 
 def _config_root() -> Path:

{swarph_cli-0.60.0 → swarph_cli-0.62.0}/src/swarph_cli/commands/init.py

@@ -37,6 +37,7 @@ _LLM_BLURBS = {
     "grok": "xAI Grok — grok membrane",
     "muse": "Muse — muse membrane",
     "vibe": "Vibe — vibe membrane",
+    "opencode": "OpenCode — opencode membrane (XDG config+data isolation)",
 }
 
 

swarph_cli-0.62.0/src/swarph_cli/commands/install_opencode_plugin.py

@@ -0,0 +1,173 @@
+"""``swarph install-opencode-plugin`` — the OpenCode plugin that wires swarph hooks.
+
+Part 2 of the opencode membrane. opencode has NO command-hook surface — its only
+hook surface is a JavaScript plugin loaded from the config dir's ``plugins/``
+tree (auto-loaded, no ``opencode.json`` ``plugin`` entry required; measured:
+``~/.config/opencode/plugin/opensling.js`` loads against a config containing only
+``$schema``). This verb renders the package payload (baking the pinned Python
+interpreter, the same reason ``install_codex_hooks`` pins it: PATH presence is
+not a liveness proof) and writes it as ``swarph-opencode.js``:
+
+* ``--scope user``    → ``~/.config/opencode/plugins/swarph-opencode.js`` —
+  the OPERATOR's bare ``opencode`` sessions (outside a swarph cell).
+* ``--scope project`` → ``<cwd>/.opencode/plugins/swarph-opencode.js`` — a
+  per-project wiring.
+
+The swarph CELL does NOT read either of those locations: its membrane relocates
+``XDG_CONFIG_HOME`` to ``<cwd>/.opencode-cell/config``, so its plugin lives at
+``<cwd>/.opencode-cell/config/opencode/plugins/swarph-opencode.js`` and is
+written by the membrane's ``_opencode_env`` via ``ensure_cell_plugin`` — a
+spawned cell is wired without a separate onboarding step.
+
+Identity (SWARPH_SELF / SWARPH_MEMORY_DIR) is read by the plugin from env AT
+RUNTIME, not baked — the membrane already stamps SWARPH_SELF into the cell env,
+and a bare-session install inherits the operator's env at hook time.
+
+Idempotent, ``--uninstall``, ``--dry-run``, write-landed assert — the same
+operator contract as every other hook installer (#527 task 3).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from importlib import resources
+from pathlib import Path
+
+from swarph_cli.cell import _atomic_write_text
+
+_PAYLOAD = "swarph_cli.payloads.opencode"
+_PLUGIN_NAME = "swarph-opencode.js"
+
+
+def _payload_text() -> str:
+    """Read the plugin FROM THE PACKAGE — never a source-tree path, so tests
+    exercise the same importlib.resources lookup an installed wheel depends on
+    (the 0.39.3 undeclared-package-data lesson)."""
+    return resources.files(_PAYLOAD).joinpath("plugin.js").read_text(encoding="utf-8")
+
+
+def _render_plugin(interpreter: str) -> str:
+    r"""Render the plugin with @PYTHON@ replaced by ``interpreter`` AS A JS STRING.
+
+    >>> shlex.quote is WRONG here, and it was the shipped defect (#423 review).
+    The placeholder sits on the RHS of ``const PY = @PYTHON@;`` — a JavaScript
+    string literal position, NOT shell text. ``shlex.quote`` wraps in single
+    quotes and leaves backslashes raw, so on Windows
+    ``C:\Program Files\Python\python.exe`` became
+    ``const PY = "'C:\Program Files\Python\python.exe'";`` — invalid escapes, and
+    the single quotes land INSIDE the double quotes, so the value is a wrong path
+    even where it parses. json.dumps produces a valid JS string literal (double
+    quoted, backslashes escaped as ``\\``), which a JS parser accepts and decodes
+    back to the exact path. The template leaves the quotes to the substitution
+    (``const PY = @PYTHON@;``) so they are never doubled. <<<
+    """
+    return _payload_text().replace("@PYTHON@", json.dumps(interpreter))
+
+
+def _render() -> str:
+    """The rendered plugin, with @PYTHON@ pinned to THIS interpreter."""
+    return _render_plugin(str(Path(sys.executable).resolve()))
+
+
+def _target(scope: str) -> Path:
+    if scope == "project":
+        return Path.cwd() / ".opencode" / "plugins" / _PLUGIN_NAME
+    return Path.home() / ".config" / "opencode" / "plugins" / _PLUGIN_NAME
+
+
+def cell_plugin_path(cwd: Path) -> Path:
+    """Where a cell's plugin lives inside its isolated config dir.
+
+    Mirrors ``_OPENCODE_CELL_SUBDIR`` + the XDG_CONFIG_HOME layout the membrane
+    sets in ``_opencode_env`` — kept here (not imported from spawn) so spawn can
+    call back into it without a cycle.
+    """
+    return cwd / ".opencode-cell" / "config" / "opencode" / "plugins" / _PLUGIN_NAME
+
+
+def ensure_cell_plugin(cwd: Path) -> None:
+    """Write the cell's plugin if absent or changed. Idempotent + best-effort:
+    a failure must not block the spawn (worst case the cell runs unhooked)."""
+    try:
+        rendered = _render()
+        target = cell_plugin_path(cwd)
+        if target.exists() and target.read_text(encoding="utf-8") == rendered:
+            return
+        target.parent.mkdir(parents=True, exist_ok=True)
+        _atomic_write_text(target, rendered)
+    except Exception:
+        pass
+
+
+def _read_existing(target: Path) -> str:
+    return target.read_text(encoding="utf-8") if target.exists() else ""
+
+
+def run_install_opencode_plugin(argv: list[str] | None = None) -> int:
+    if argv is None:
+        argv = sys.argv[2:]
+
+    p = argparse.ArgumentParser(prog="swarph install-opencode-plugin")
+    p.add_argument("--scope", choices=("user", "project"), default="user")
+    p.add_argument("--uninstall", action="store_true")
+    p.add_argument("--dry-run", action="store_true")
+    args = p.parse_args(argv)
+
+    target = _target(args.scope)
+
+    if args.dry_run:
+        print(f"# swarph install-opencode-plugin --dry-run", file=sys.stderr)
+        print(f"#   scope:  {args.scope}", file=sys.stderr)
+        print(f"#   target: {target}", file=sys.stderr)
+        print(f"#   action: {'uninstall' if args.uninstall else 'install'}", file=sys.stderr)
+        if not args.uninstall:
+            print(_render())
+        return 0
+
+    if args.uninstall:
+        existed = target.exists()
+        if existed:
+            target.unlink()
+        print(
+            f"swarph install-opencode-plugin: uninstalled {_PLUGIN_NAME} from "
+            f"{target} ({'removed' if existed else 'was absent'}).",
+            file=sys.stderr,
+        )
+        return 0
+
+    rendered = _render()
+    if _read_existing(target) == rendered:
+        print(
+            f"swarph install-opencode-plugin: no change needed at {target} "
+            "(plugin already in desired state).",
+            file=sys.stderr,
+        )
+        return 0
+
+    target.parent.mkdir(parents=True, exist_ok=True)
+    _atomic_write_text(target, rendered)
+    # The #527 task-3 assert: "installed" is a claim about the filesystem.
+    if target.read_text(encoding="utf-8") != rendered:
+        print(
+            f"swarph install-opencode-plugin: WRITE DID NOT LAND — {target} "
+            "re-reads as different content than was written. The install is NOT "
+            "in effect.",
+            file=sys.stderr,
+        )
+        return 2
+    print(
+        f"swarph install-opencode-plugin: installed {_PLUGIN_NAME} at {target}.",
+        file=sys.stderr,
+    )
+    print(
+        "NOTE: opencode loads the plugin table at session start. Already-open "
+        "sessions keep the pre-edit table — open a FRESH session before testing.",
+        file=sys.stderr,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(run_install_opencode_plugin(sys.argv[1:]))

{swarph_cli-0.60.0 → swarph_cli-0.62.0}/src/swarph_cli/commands/memory_emit_hook.py

@@ -67,15 +67,37 @@ def _memory_slug(file_path: str) -> Optional[str]:
 
 
 def _snippet(path: Path) -> str:
-    """First non-empty line, de-headed, collapsed, truncated. Unreadable file →
-    empty snippet (the pointer still emits — the write happened either way)."""
+    """One-line summary of a memory: its frontmatter `description`, else the first body
+    line. Unreadable file → empty snippet (the pointer still emits — the write happened).
+
+    Every memory file opens with YAML frontmatter, so "first non-empty line" returned the
+    literal `---` delimiter. That is a NON-EMPTY STRING, so the caller's `if snippet` guard
+    passed and the timeline took `memory cached: ---`. MEASURED 2026-09-15: 21 such entries
+    on the shared timeline between 2026-08-25 and 2026-09-15, every one of them useless.
+    An emptiness guard cannot catch a delimiter; the fix has to be here, not at the guard.
+    """
     try:
-        for line in path.read_text(encoding="utf-8", errors="replace").splitlines():
-            s = line.strip().lstrip("#").strip()
-            if s:
-                return " ".join(s.split())[:_SNIPPET_CHARS]
+        lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
     except Exception:
-        pass
+        return ""
+    body = lines
+    if lines and lines[0].strip() == "---":
+        for i, line in enumerate(lines[1:], start=1):
+            if line.strip() == "---":
+                # `description:` exists precisely to be a one-line summary — prefer it.
+                for fm in lines[1:i]:
+                    if fm.strip().lower().startswith("description:"):
+                        d = fm.split(":", 1)[1].strip().strip('"').strip("'")
+                        if d:
+                            return " ".join(d.split())[:_SNIPPET_CHARS]
+                body = lines[i + 1:]
+                break
+        else:
+            body = lines[1:]          # unterminated frontmatter: skip the opening delimiter
+    for line in body:
+        s = line.strip().lstrip("#").strip()
+        if s and s != "---":          # a stray delimiter is never a summary
+            return " ".join(s.split())[:_SNIPPET_CHARS]
     return ""
 
 

{swarph_cli-0.60.0 → swarph_cli-0.62.0}/src/swarph_cli/commands/monitor.py

@@ -1703,7 +1703,7 @@ def _cmd_clear_reexec_hold(args: argparse.Namespace) -> int:
     return 0
 
 
-def _resolve_consumed_tree(swarph_bin: str) -> tuple:
+def _resolve_consumed_tree(swarph_bin: str, pythonpath: str = None) -> tuple:
     """#807: (interpreter, init_path, how) for the tree the swarph BINARY loads.
     Reads the shim's shebang, asks that interpreter where swarph_cli lives. The
     installer's own interpreter is the wrong witness (a pipx-run installer watched
@@ -1722,6 +1722,8 @@ def _resolve_consumed_tree(swarph_bin: str) -> tuple:
     # whoever runs the installer (a dev shell's PYTHONPATH=src would otherwise be
     # reported as "the tree the monitors load" — the exact misreading this fixes).
     env = {k: v for k, v in os.environ.items() if k not in ("PYTHONPATH", "PYTHONHOME", "PYTHONSAFEPATH")}
+    if pythonpath:
+        env["PYTHONPATH"] = pythonpath
     try:
         r = subprocess.run([interp, "-c", "import swarph_cli, sys; print(swarph_cli.__file__)"],
                            capture_output=True, text=True, encoding="utf-8", errors="replace",
@@ -1733,6 +1735,55 @@ def _resolve_consumed_tree(swarph_bin: str) -> tuple:
     return interp, r.stdout.strip().replace("\\", "/"), f"resolved from {swarph_bin} -> {interp}"
 
 
+_USER_SITE_RE = re.compile(r"^(.*/\.local/lib/python[0-9]+\.[0-9]+/site-packages)/swarph_cli/__init__\.py$")
+
+
+def _user_site_of(init_path: str):
+    """The user-site dir a swarph_cli __init__ lives in, or None (pipx venv, system)."""
+    m = _USER_SITE_RE.match((init_path or "").replace("\\", "/"))
+    return m.group(1) if m else None
+
+
+def _owner_user_site(swarph_bin: str, interp: str):
+    """#807 (root cannot see the user site): the pip --user tree of the SHIM'S OWNER for
+    the shim's interpreter — ~owner/.local/lib/pythonX.Y/site-packages — if swarph_cli
+    is there. The unit runs as root and root's interpreter never searches another
+    user's site, so the installer must find it by construction, not by import."""
+    import pwd, subprocess
+    try:
+        home = pwd.getpwuid(Path(swarph_bin).stat().st_uid).pw_dir
+        r = subprocess.run([interp, "-c", "import sys; print('%d.%d' % sys.version_info[:2])"],
+                           capture_output=True, text=True, encoding="utf-8", errors="replace",
+                           timeout=20)
+    except (OSError, KeyError, subprocess.SubprocessError):
+        return None
+    ver = r.stdout.strip()
+    if r.returncode != 0 or not re.fullmatch(r"[0-9]+\.[0-9]+", ver):
+        return None
+    cand = f"{home}/.local/lib/python{ver}/site-packages"
+    return cand if Path(cand, "swarph_cli", "__init__.py").exists() else None
+
+
+def _condition_probe(interpreter: str, pythonpath: str = None) -> tuple:
+    """Run the unit's ExecCondition NOW, as the user running this verb, with the env the
+    unit will have. (ok, detail). The 2026-09-15 lesson: a condition that fails on every
+    fire is a SKIP (Result=success) — OnFailure never fires, and the unit is quieter than
+    the failed state it replaced. So the writer checks it before it writes."""
+    import subprocess
+    env = {k: v for k, v in os.environ.items() if k not in ("PYTHONPATH", "PYTHONHOME", "PYTHONSAFEPATH")}
+    if pythonpath:
+        env["PYTHONPATH"] = pythonpath
+    try:
+        r = subprocess.run([interpreter, "-c", "import swarph_cli"], capture_output=True, text=True,
+                           encoding="utf-8", errors="replace", timeout=20, env=env)
+    except (OSError, subprocess.SubprocessError) as e:
+        return False, f"{interpreter} could not be run ({type(e).__name__})"
+    if r.returncode == 0:
+        return True, "OK"
+    last = (r.stderr.strip().splitlines() or ["(no stderr)"])[-1]
+    return False, f"rc={r.returncode}: {last}"
+
+
 def _live_tree():
     """The tree the INSTALLER's own interpreter loads (a pipx-run installer reports the
     pipx venv), asked through the same scrubbed child as the consumed tree, so a dev
@@ -1772,12 +1823,39 @@ def _cmd_install_reexec(args: argparse.Namespace) -> int:
     # interpreter, not the interpreter running this verb.
     interpreter, init_path, how = _resolve_consumed_tree(swarph_bin)
     live_init = _live_tree()
+    pythonpath = None
+    if init_path is None and interpreter:
+        # #807 (2026-09-15): run as root, the shim's interpreter cannot import a pip
+        # --user install at all — the same ModuleNotFoundError as a mid-install
+        # window, on EVERY fire. Find the owner's user site by construction.
+        us = _owner_user_site(swarph_bin, interpreter)
+        if us:
+            _i, init2, how2 = _resolve_consumed_tree(swarph_bin, pythonpath=us)
+            if init2:
+                init_path, how = init2, (f"{how2} via the shim owner's user site — {interpreter} "
+                                         f"alone cannot import it (this user is not the owner, e.g. root)")
     if init_path is None:
         if live_init is None:
             raise RuntimeError("cannot resolve the installed swarph_cli package "
                                "path — is this a broken install?")
         init_path, how = live_init, f"{how}; fell back to the LIVE interpreter"
     extra_trees = [t for t in {live_init} if t and t != init_path]
+    # A user-site tree is invisible to root's interpreter: the unit runs as root, so
+    # the site the monitors load is handed to it explicitly. A pipx/venv tree needs
+    # nothing (its interpreter owns its site) and gets no Environment= line.
+    pythonpath = _user_site_of(init_path)
+    env_line = f"Environment=PYTHONPATH={pythonpath}\n" if pythonpath else ""
+    # Provenance (2026-09-15): a unit on disk could not say what produced it, so a
+    # render from an unreleased checkout was indistinguishable from a release.
+    # The PACKAGE PATH is the field that tells a release apart from a checkout: an
+    # unreleased tree reports the last release's __version__ until the bump, and
+    # the interpreter is the same either way (lab-ovh, #420 review, measured).
+    import swarph_cli as _pkg
+    from swarph_cli import __version__ as _ver
+    from datetime import datetime, timezone
+    rendered_by = (f"swarph-cli {_ver} ({str(_pkg.__file__).replace(chr(92), '/')}) "
+                   f"install-reexec, {sys.executable}, "
+                   f"{datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')}")
     rendered = {}
     for name, rel in _REEXEC_TEMPLATES.items():
         text = _read_packaged(rel)
@@ -1785,7 +1863,9 @@ def _cmd_install_reexec(args: argparse.Namespace) -> int:
                .replace("<SITE_PACKAGES_INIT>", init_path)
                .replace("<INTERPRETER>", interpreter or sys.executable)
                .replace("<SWARPH_BIN>", swarph_bin)
-               .replace("<STATE_ROOT>", state_root))
+               .replace("<STATE_ROOT>", state_root)
+               .replace("<ENV_PYTHONPATH>\n", env_line)
+               .replace("<RENDERED_BY>", rendered_by))
         if name.endswith(".path") and extra_trees:
             out = out.replace(f"PathChanged={init_path}\n",
                               f"PathChanged={init_path}\n"
@@ -1803,6 +1883,9 @@ def _cmd_install_reexec(args: argparse.Namespace) -> int:
             dropins[f"{name}.d/10-onfailure.conf"] = (
                 f"# #807: written by `swarph monitor install-reexec --on-failure`; box-local.\n"
                 f"[Unit]\nOnFailure={args.on_failure}\n")
+    import getpass
+    cond_ok, cond_detail = _condition_probe(interpreter or sys.executable, pythonpath)
+    who = getpass.getuser()
     if not args.write:
         for name, text in rendered.items():
             print(f"# ── {name} ──")
@@ -1811,6 +1894,8 @@ def _cmd_install_reexec(args: argparse.Namespace) -> int:
             print(f"# ── {name} ──")
             print(text, end="")
         print(f"# watching: {init_path} ({how})")
+        print(f"# condition check as {who}: {'OK' if cond_ok else 'FAILS — ' + cond_detail}"
+              + ("" if cond_ok else " (the unit would be SKIPPED on every fire; --write will refuse)"))
         for t in extra_trees:
             print(f"# also watching: {t} (a second install tree; the monitors do not load it)")
         print(f"# import check: {interpreter or sys.executable} -c 'import swarph_cli'")
@@ -1822,6 +1907,13 @@ def _cmd_install_reexec(args: argparse.Namespace) -> int:
         print("swarph monitor install-reexec --write: Linux-only.",
               file=sys.stderr)
         return 2
+    if not cond_ok:
+        print(f"swarph monitor install-reexec --write: REFUSED — the ExecCondition this unit would "
+              f"carry fails right now for {who}: {interpreter or sys.executable} -c 'import swarph_cli' "
+              f"→ {cond_detail}. Installed, it would be SKIPPED on every fire (Result=success, no "
+              f"OnFailure) — a control quieter than the failed state it replaces. Nothing written.",
+              file=sys.stderr)
+        return 2
     target_dir = Path(args.dir)
     if not target_dir.is_dir() or not os.access(target_dir, os.W_OK):
         print(f"swarph monitor install-reexec: {target_dir} is not writable — "
@@ -1836,6 +1928,7 @@ def _cmd_install_reexec(args: argparse.Namespace) -> int:
         (target_dir / name).write_text(text, encoding="utf-8")
         print(f"wrote {target_dir / name}")
     print(f"watching: {init_path} ({how})")
+    print(f"condition check as {who}: OK" + (f" (PYTHONPATH={pythonpath})" if pythonpath else ""))
     for t in extra_trees:
         print(f"also watching: {t}")
     print("next: systemctl daemon-reload && systemctl reset-failed swarph-monitor-reexec.path "