swarph-cli 0.40.1__tar.gz → 0.40.3__tar.gz

{swarph_cli-0.40.1/src/swarph_cli.egg-info → swarph_cli-0.40.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.40.1
+Version: 0.40.3
 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`, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.40.1 → swarph_cli-0.40.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.40.1"
+version = "0.40.3"
 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`, session `import`, and a stranded-session `watchdog`."
 readme = "README.md"
 license = { text = "MIT" }

{swarph_cli-0.40.1 → swarph_cli-0.40.3}/src/swarph_cli/__init__.py

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

{swarph_cli-0.40.1 → swarph_cli-0.40.3}/src/swarph_cli/commands/daemon.py

@@ -50,6 +50,7 @@ from pathlib import Path
 from typing import Optional
 
 from swarph_cli import session_bridge, stall_alert
+from swarph_cli.console_safe import print_safe
 from swarph_cli.delivery_queue import DeliveryQueue
 
 
@@ -294,53 +295,11 @@ def _log_dm(state: DaemonState, dm: dict) -> None:
     _print_safe(line)
 
 
-def _print_safe(line: str, *, stream=None, file=None, flush: bool = True) -> None:
-    """Print, degrading to a lossy transliteration rather than raising.
-
-    A console whose encoding cannot represent a DM (cp1252 on a French Windows box,
-    any 8-bit codepage) must cost a mangled character, never a poll iteration.
-
-    >>> EVERY output path in this module goes through here, not just the DM line. <<<
-    droplet measured the first version's coverage at 1 call site out of 13, and named
-    the one that matters: the delivery-error handler in `attempt_delivery`, whose own
-    comment promises it will never crash the loop. A raise inside an `except` block
-    propagates past the `try` entirely — so the handler reached ONLY when something has
-    already gone wrong was itself the crash, on precisely the text most likely to carry
-    our characters (an exception message).
-
-    cp1252 coverage of what this fleet actually emits, measured:
-        renders : em-dash, bullet, accented e, guillemet
-        RAISES  : arrow, box-drawing, emoji, check-mark
-    Our DMs and operator lines are full of arrows and emoji, and the em-dash is FINE —
-    so the original DM-blindness was an arrow or an emoji, never punctuation.
-
-    A SYMBOL GREP MEASURES PRESENCE, NOT COVERAGE: `grep _print_safe` returns 1 whether
-    this guards one path or all thirteen. Coverage is asserted by a test that walks the
-    module's AST for unguarded `print(` calls, not by the symbol existing.
-    """
-    # `file=` is accepted as an alias for `stream=`, and `flush` is accepted and
-    # ignored (this always flushes). Deliberate: every call site here was a `print`,
-    # and a future author reaching for the print spelling must land in the guard
-    # rather than a TypeError — a TypeError in the delivery-error handler is the
-    # exact crash this function exists to prevent, merely with a different name.
-    out = stream if stream is not None else (file if file is not None else sys.stdout)
-    try:
-        print(line, file=out, flush=True)
-    except UnicodeEncodeError:
-        enc = getattr(out, "encoding", None) or "ascii"
-        try:
-            out.write(line.encode(enc, errors="replace").decode(enc, errors="replace"))
-            out.write("\n")
-            out.flush()
-        except (OSError, UnicodeEncodeError, ValueError):
-            # The fallback failing must not resurrect the crash it exists to prevent.
-            # Losing an operator line is survivable; losing the loop is not.
-            pass
-    except (OSError, ValueError):
-        # A closed/broken stream (detached service, full disk) is not a reason to stop
-        # draining — the audit write already succeeded. ValueError covers
-        # write-on-closed-file, which service teardown reaches.
-        pass
+# The guard now lives in swarph_cli.console_safe so the modules daemon IMPORTS
+# (delivery_queue, stall_alert, session_bridge) can use it too — siting it here
+# is what left them unguarded in the published 0.40.1. Alias kept: _print_safe is
+# this module's established spelling and the AST coverage test keys on it.
+_print_safe = print_safe
 
 
 def _route_to_handler(state: DaemonState, dm: dict) -> None:

{swarph_cli-0.40.1 → swarph_cli-0.40.3}/src/swarph_cli/commands/onboard.py

@@ -32,6 +32,7 @@ import urllib.request
 from getpass import getpass
 from pathlib import Path
 from typing import Optional
+from swarph_cli.console_safe import print_safe
 
 
 _HANDSHAKE_TEMPLATE = """\
@@ -147,7 +148,7 @@ def _resolve_token(token_file_arg: Optional[str]) -> str:
         try:
             mode = secrets_path.stat().st_mode & 0o777
             if mode != 0o600:
-                print(
+                print_safe(
                     f"swarph onboard: WARNING: {secrets_path} mode is {oct(mode)}, "
                     f"expected 0600. Continuing — fix manually with `chmod 600 {secrets_path}`.",
                     file=sys.stderr,
@@ -162,11 +163,11 @@ def _resolve_token(token_file_arg: Optional[str]) -> str:
                     if val:
                         return val
         except Exception as exc:
-            print(
+            print_safe(
                 f"swarph onboard: failed to read {secrets_path}: {exc}", file=sys.stderr
             )
 
-    print(
+    print_safe(
         f"swarph onboard: MESH_GATEWAY_TOKEN not in env, not found in {secrets_path}.\n"
         f"  Canonical secrets.toml shape (mode 0600):\n"
         f"    MESH_GATEWAY_TOKEN=<your-token>\n"
@@ -225,7 +226,7 @@ def run_onboard(argv: list[str]) -> int:
     args = _build_parser().parse_args(argv)
 
     # ── Step 1: validate_node_name ───────────────────────────────────
-    print(f"[1/6] validate_node_name({args.peer!r})")
+    print_safe(f"[1/6] validate_node_name({args.peer!r})")
     try:
         from swarph_shared.peer_registry import (
             validate_node_name,
@@ -233,7 +234,7 @@ def run_onboard(argv: list[str]) -> int:
             GatewayUnreachableError,
         )
     except ImportError as exc:
-        print(f"swarph onboard: missing swarph-shared>=0.2.0: {exc}", file=sys.stderr)
+        print_safe(f"swarph onboard: missing swarph-shared>=0.2.0: {exc}", file=sys.stderr)
         return 1
 
     # NotInRegistry is expected here — onboard's whole point is that
@@ -241,24 +242,24 @@ def run_onboard(argv: list[str]) -> int:
     try:
         from swarph_shared.peer_registry import NAMING_CONVENTION_REGEX, KNOWN_ALIASES
     except ImportError:
-        print("swarph onboard: peer_registry primitives missing", file=sys.stderr)
+        print_safe("swarph onboard: peer_registry primitives missing", file=sys.stderr)
         return 1
 
     canonical = KNOWN_ALIASES.get(args.peer, args.peer)
     if canonical != args.peer:
-        print(
+        print_safe(
             f"      WARN: {args.peer!r} resolved to canonical {canonical!r} "
             f"(contagion alias)",
             file=sys.stderr,
         )
     if not NAMING_CONVENTION_REGEX.match(canonical):
-        print(
+        print_safe(
             f"swarph onboard: {canonical!r} fails naming convention "
             f"(^[a-z][a-z0-9-]*[a-z0-9]$)",
             file=sys.stderr,
         )
         return 1
-    print(f"      ok ({canonical!r})")
+    print_safe(f"      ok ({canonical!r})")
 
     # ── Step 2: would-write peer-registry row (effectively step 4) ───
     # The PLAN's step 2 is logically subsumed by step 4 (the gateway
@@ -267,40 +268,40 @@ def run_onboard(argv: list[str]) -> int:
     capabilities = dict(_parse_capability(c) for c in args.capability) if args.capability else {
         "can_claim_tasks": True
     }
-    print(f"[2/6] prepare peer-registry row (caps={capabilities})")
+    print_safe(f"[2/6] prepare peer-registry row (caps={capabilities})")
 
     # ── Step 3: resolve MESH_GATEWAY_TOKEN ───────────────────────────
-    print("[3/6] resolve MESH_GATEWAY_TOKEN")
+    print_safe("[3/6] resolve MESH_GATEWAY_TOKEN")
     token = _resolve_token(args.token_file)
     if not token:
-        print("swarph onboard: empty token", file=sys.stderr)
+        print_safe("swarph onboard: empty token", file=sys.stderr)
         return 1
-    print("      ok")
+    print_safe("      ok")
 
     # ── Step 4: POST /peers/register ─────────────────────────────────
     peer_url = args.url or f"http://{canonical}:8787"
-    print(f"[4/6] POST {args.gateway}/peers/register")
+    print_safe(f"[4/6] POST {args.gateway}/peers/register")
     status, body = _post_json(
         f"{args.gateway}/peers/register",
         {"name": canonical, "url": peer_url, "capabilities": capabilities},
         token,
     )
     if status != 200:
-        print(
+        print_safe(
             f"swarph onboard: gateway register failed: {status} {body}",
             file=sys.stderr,
         )
         return 2
     if body.get("registered_unratified") is False:
-        print(
+        print_safe(
             f"      ok (already ratified — peer existed pre-Phase-5.5 or was "
             f"witness-flipped already)"
         )
     else:
-        print(f"      ok (registered_unratified=true)")
+        print_safe(f"      ok (registered_unratified=true)")
 
     # ── Step 5: subscription auth check ──────────────────────────────
-    print("[5/6] verify_subscription_setup()")
+    print_safe("[5/6] verify_subscription_setup()")
     try:
         from swarph_shared import verify_subscription_setup
 
@@ -308,9 +309,9 @@ def run_onboard(argv: list[str]) -> int:
         # catch broadly so onboarding doesn't blow up on Claude-runtime-only
         # checks when the peer is non-Claude (§15.6 #10 deferred to Phase 6).
         verify_subscription_setup()
-        print("      ok (Claude subscription credentials + binary verified)")
+        print_safe("      ok (Claude subscription credentials + binary verified)")
     except Exception as exc:
-        print(
+        print_safe(
             f"      WARN: {type(exc).__name__}: {exc}\n"
             f"      Subscription path won't work for this peer until resolved. "
             f"Non-Claude runtimes (Gemini, etc.) ship in Phase 6 per §15.6 #10.",
@@ -324,7 +325,7 @@ def run_onboard(argv: list[str]) -> int:
         else Path.home() / "swarph_state"
     )
     peer_dir = state_root / canonical
-    print(f"[6/6] scaffold {peer_dir}")
+    print_safe(f"[6/6] scaffold {peer_dir}")
     peer_dir.mkdir(parents=True, exist_ok=True)
     try:
         peer_dir.chmod(0o700)
@@ -361,7 +362,7 @@ def run_onboard(argv: list[str]) -> int:
             daemon_sh.chmod(0o755)
         except OSError:
             pass  # best-effort; Windows or fs without POSIX modes
-    print(f"      ok (inbox.log, cursor.json, .env.example, run-daemon.sh)")
+    print_safe(f"      ok (inbox.log, cursor.json, .env.example, run-daemon.sh)")
 
     # ── Step 7: handshake template (MANUAL) ──────────────────────────
     # tempfile.gettempdir() is the platform temp dir ('/tmp' on POSIX, the
@@ -374,7 +375,7 @@ def run_onboard(argv: list[str]) -> int:
         ),
         encoding="utf-8",
     )
-    print(
+    print_safe(
         f"\n[manual] handshake template at {tmp_path}\n"
         f"  Edit each section in your own words, then send to your witness peer.\n"
         f"  After witness reads + judges sufficient, they run:\n"

{swarph_cli-0.40.1 → swarph_cli-0.40.3}/src/swarph_cli/commands/schedule.py

@@ -40,7 +40,13 @@ def _build_parser() -> argparse.ArgumentParser:
         "--context",
         action="append",
         default=[],
-        help="context reference (repeatable)",
+        metavar="KEY=VALUE",
+        help="durable context anchor, repeatable. KEY is one of "
+             + "|".join(sorted(DURABLE_ANCHOR_KEYS))
+             + " (e.g. --context memory=project_x --context repo=swarph-cli). "
+             "A raw JSON object is also accepted. REQUIRED: the gateway rejects an "
+             "event with no anchors, because an event that fires with no durable "
+             "context wakes a cell that cannot reconstruct why.",
     )
     create.add_argument(
         "--min-interval",
@@ -93,14 +99,81 @@ def _ctx(args: argparse.Namespace) -> tuple[str, str, str]:
     return self_name, token, base
 
 
+
+# Mirrors mesh-gateway `_DURABLE_ANCHOR_KEYS` (server.py). Kept in sync by
+# test_schedule_create_contract.py, which fails if this drifts from the value the
+# gateway actually enforces — a duplicated constant nobody checks is how the two
+# sides diverged in the first place.
+DURABLE_ANCHOR_KEYS = frozenset({"repo", "memory", "channel", "feature", "file"})
+
+
+def parse_context_anchor(raw: str) -> dict:
+    """Turn one --context value into the ANCHOR DICT the gateway requires.
+
+    >>> THE BUG THIS FIXES (card #146): the CLI sent `--context` values through as
+        RAW STRINGS while the gateway requires each anchor to be a DICT carrying a
+        durable key, and requires the list to be NON-EMPTY. So `swarph schedule
+        create` COULD NOT SUCCEED — every invocation 400'd, and every real event on
+        this mesh had to be armed by hand over the raw API. <<<
+
+    That is why dated reminders kept living in DM threads instead of the scheduler:
+    the verb that makes a date fire was itself broken, so the cheapest path was
+    always to tell a peer and hope.
+
+    Accepts `key=value` for the five durable kinds, or a raw JSON object for
+    anything the shorthand cannot express. Raises ValueError with the valid keys
+    listed, LOCALLY — a 400 from the gateway names the rule but not the input that
+    broke it, and the user is holding the input.
+    """
+    raw = (raw or "").strip()
+    if not raw:
+        raise ValueError("empty --context value")
+    if raw.startswith("{"):
+        try:
+            anchor = json.loads(raw)
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"--context {raw!r} looks like JSON but does not parse: {exc}") from exc
+        if not isinstance(anchor, dict):
+            raise ValueError(f"--context JSON must be an object, got {type(anchor).__name__}")
+        if not (set(anchor) & DURABLE_ANCHOR_KEYS):
+            raise ValueError(
+                f"--context {raw!r} has no durable key; one of "
+                f"{sorted(DURABLE_ANCHOR_KEYS)} is required")
+        return anchor
+    key, sep, value = raw.partition("=")
+    key, value = key.strip(), value.strip()
+    if not sep or not value:
+        raise ValueError(
+            f"--context {raw!r} must be KEY=VALUE (e.g. memory=project_x); "
+            f"KEY is one of {sorted(DURABLE_ANCHOR_KEYS)}")
+    if key not in DURABLE_ANCHOR_KEYS:
+        raise ValueError(
+            f"--context key {key!r} is not durable; use one of {sorted(DURABLE_ANCHOR_KEYS)}. "
+            f"An anchor must name something that survives compaction — a /tmp path or a "
+            f"session id is exactly what the gateway rejects.")
+    return {key: value}
+
+
 def _run_create(args: argparse.Namespace) -> int:
     self_name, token, base = _ctx(args)
+    if not args.context:
+        print("swarph schedule create: --context is REQUIRED (repeatable).\n"
+              "  The gateway refuses an event with no durable anchor: an event that\n"
+              "  fires with no context wakes a cell that cannot reconstruct why it woke.\n"
+              f"  Use KEY=VALUE with KEY in {sorted(DURABLE_ANCHOR_KEYS)},\n"
+              "  e.g. --context memory=project_graduation_register", file=sys.stderr)
+        return 2
+    try:
+        anchors = [parse_context_anchor(c) for c in args.context]
+    except ValueError as exc:
+        print(f"swarph schedule create: {exc}", file=sys.stderr)
+        return 2
     body = {
         "name": args.name,
         "trigger_type": args.trigger,
         "target_cell": args.target,
         "task": args.task,
-        "context_ref": args.context,
+        "context_ref": anchors,
         "created_by": self_name,
     }
     if args.cron is not None:

swarph_cli-0.40.3/src/swarph_cli/console_safe.py

@@ -0,0 +1,78 @@
+"""Encoding-safe operator output — the one place the daemon's loop may print from.
+
+WHY THIS IS ITS OWN MODULE rather than a helper inside ``commands/daemon.py``:
+the modules that most need the guard are the ones ``daemon`` IMPORTS
+(``delivery_queue``, ``stall_alert``, ``session_bridge``), so they cannot import it
+back. The guard living in the consumer meant the producers went unguarded — and
+that is exactly where the two surviving crashes were found (``delivery_queue.py:43``,
+``stall_alert.py:49``), by droplet, in the PUBLISHED 0.40.1 artifact.
+
+>>> THE GUARD'S HOME WAS ITSELF A COVERAGE BOUNDARY. A protection sited inside one
+    module protects one module, however carefully that module is then audited. <<<
+
+THE BUG IT EXISTS FOR. On a console whose encoding cannot represent a character
+(cp1252 on a French Windows box, any 8-bit codepage), ``print`` raises
+``UnicodeEncodeError``. In an ``except`` block that raise propagates past the ``try``
+entirely — so an error handler whose whole contract is "never crash the loop" becomes
+the crash, and it does so on the text MOST likely to carry an unrepresentable
+character: an interpolated exception message.
+
+Measured cp1252 coverage of what this fleet actually emits:
+
+====================================  ==========
+em-dash, bullet, accented e, guillemet  renders
+arrow, box-drawing, emoji, check-mark   RAISES
+====================================  ==========
+
+The em-dash renders, so the original DM-blindness on workstation-lc was an arrow or
+an emoji — never punctuation.
+
+A SYMBOL GREP MEASURES PRESENCE, NOT COVERAGE: ``grep -c _print_safe`` returns 1
+whether this guards one call site or every one. Coverage is asserted by an AST walk
+over every module the daemon's loop can reach (``test_daemon_console_encoding.py``),
+and that test is itself proven non-vacuous by reintroducing a bare ``print``.
+"""
+
+from __future__ import annotations
+
+import sys
+
+__all__ = ["print_safe"]
+
+
+def print_safe(line: str, *, stream=None, file=None, flush: bool = True) -> None:
+    """Print, degrading to a lossy transliteration rather than raising.
+
+    A console that cannot represent the text must cost a mangled character, never a
+    poll iteration. Callers that also persist the line (the daemon's inbox audit)
+    write to disk in utf-8 BEFORE calling here, so a cp1252 box loses glyphs from its
+    screen and never messages from its inbox.
+
+    ``file=`` is accepted as an alias for ``stream=``, and ``flush`` is accepted and
+    ignored (this always flushes). Deliberate rather than sloppy: every call site was
+    once a ``print``, and a future author reaching for the print spelling must land in
+    the guard rather than a ``TypeError`` — a ``TypeError`` inside the delivery-error
+    handler is the same crash this function exists to prevent, wearing another name.
+
+    Passing both ``stream=`` and ``file=`` with different targets silently uses
+    ``stream``. Recorded decision, not an accident (droplet, PR #158): raising on the
+    nonsensical call would put a new ``raise`` inside the one function whose entire
+    contract is that it never raises — the cure would be the disease.
+    """
+    out = stream if stream is not None else (file if file is not None else sys.stdout)
+    try:
+        print(line, file=out, flush=True)
+    except UnicodeEncodeError:
+        enc = getattr(out, "encoding", None) or "ascii"
+        try:
+            out.write(line.encode(enc, errors="replace").decode(enc, errors="replace"))
+            out.write("\n")
+            out.flush()
+        except (OSError, UnicodeEncodeError, ValueError, AttributeError):
+            # The fallback failing must not resurrect the crash it exists to prevent.
+            # Losing an operator line is survivable; losing the loop is not.
+            pass
+    except (OSError, ValueError):
+        # A closed/broken stream (detached service, full disk) is no reason to stop
+        # draining. ValueError covers write-on-closed-file, which teardown reaches.
+        pass

{swarph_cli-0.40.1 → swarph_cli-0.40.3}/src/swarph_cli/delivery_queue.py

@@ -9,6 +9,7 @@ import os
 import sys
 from pathlib import Path
 from typing import List
+from swarph_cli.console_safe import print_safe
 
 
 def wake_for(kind: str, thread_id) -> bool:
@@ -40,7 +41,7 @@ class DeliveryQueue:
             # Corruption: reset to empty but LOG it — since the cursor advanced
             # on drain, wiped entries won't be re-fetched, so a silent reset
             # would lose DMs from the session (spec: "treat as empty, log, continue").
-            print(f"[swarph-daemon] delivery queue unreadable at {self.path} "
+            print_safe(f"[swarph-daemon] delivery queue unreadable at {self.path} "
                   f"({type(exc).__name__}: {exc}); starting empty — any queued "
                   f"DMs survive only in inbox.log", file=sys.stderr, flush=True)
             self._pending = []

{swarph_cli-0.40.1 → swarph_cli-0.40.3}/src/swarph_cli/gateway/server.py

@@ -2437,8 +2437,15 @@ def _is_operator(auth: AuthContext) -> bool:
     membership/broadcast authority of the FUTURE POST surface is likewise REAL
     only post-C5 (a cell can already create an announce channel + own
     allow_broadcast=1 on it). Mitigation now: pre-seed the reserved names via the
-    operator at deploy so the PK-409 protects the canonical names meanwhile."""
-    return auth.peer is None
+    operator at deploy so the PK-409 protects the canonical names meanwhile.
+
+    META-EDGE (B1/B2): a verified SSO login (kind='user_identity') and a
+    cell-join key (kind='cell_join') BOTH carry peer=None, so a bare
+    `peer is None` check made every OAuth login a full operator — an
+    OAuth-driven operator factory. The genuine operator is the shared/commander
+    token ALONE, which is the only context with BOTH peer=None AND kind=None.
+    A Meta-Edge context is owner-scoped, never operator."""
+    return auth.peer is None and auth.kind is None
 
 
 class ChannelCreateRequest(BaseModel):

{swarph_cli-0.40.1 → swarph_cli-0.40.3}/src/swarph_cli/stall_alert.py

@@ -8,6 +8,7 @@ import json
 import sys
 import urllib.error
 import urllib.request
+from swarph_cli.console_safe import print_safe
 
 _STALL_FIRST = 6  # first alert after this many consecutive deferred ticks
 
@@ -46,6 +47,6 @@ def send_stall_alert(gateway: str, token: str, self_name: str,
         with urllib.request.urlopen(req, timeout=10) as resp:
             return 200 <= resp.status < 300
     except (urllib.error.URLError, OSError, ValueError) as exc:
-        print(f"[swarph-daemon] stall-alert POST failed: {exc}",
+        print_safe(f"[swarph-daemon] stall-alert POST failed: {exc}",
               file=sys.stderr, flush=True)
         return False

{swarph_cli-0.40.1 → swarph_cli-0.40.3/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.40.1
+Version: 0.40.3
 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`, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.40.1 → swarph_cli-0.40.3}/src/swarph_cli.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ src/swarph_cli/__init__.py
 src/swarph_cli/caller.py
 src/swarph_cli/cell.py
 src/swarph_cli/chain_token.py
+src/swarph_cli/console_safe.py
 src/swarph_cli/delivery_queue.py
 src/swarph_cli/main.py
 src/swarph_cli/multiplexer.py
@@ -188,6 +189,7 @@ tests/test_providers_isolation.py
 tests/test_ratify_command.py
 tests/test_repl_caller_convention.py
 tests/test_schedule_command.py
+tests/test_schedule_create_contract.py
 tests/test_security.py
 tests/test_service_app.py
 tests/test_service_command.py

{swarph_cli-0.40.1 → swarph_cli-0.40.3}/tests/test_brain_ask_command.py

@@ -17,7 +17,7 @@ from swarph_cli.commands import brain_ask as ba
 
 def test_version_is_0_33_0():
     import swarph_cli
-    assert swarph_cli.__version__ == "0.40.1"
+    assert swarph_cli.__version__ == "0.40.3"
 
 
 # --- request / response plumbing -------------------------------------------