swarph-cli 0.9.3__tar.gz → 0.9.4__tar.gz

{swarph_cli-0.9.3/src/swarph_cli.egg-info → swarph_cli-0.9.4}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.9.3
-Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider spawn (claude/codex/antigravity per cell.provider via a ProviderMembrane), `swarph init` (interactive cell.yaml scaffolder), `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.3 adds `swarph init` + hardens assisted_memory restore (fail-closed pull, empty-guards, codex AGENTS.md) and the mesh sidecar (no DM-loss on idle-guard).
+Version: 0.9.4
+Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider `swarph spawn` (claude/codex/antigravity per cell.provider via a ProviderMembrane + subprocess billing-scrub), interactive `swarph init`, `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.4: fixes session-pin resume across a changed cwd.
 Author: Pierre Samson, Claude Opus
 License: MIT
 Project-URL: Homepage, https://github.com/darw007d/swarph-cli

{swarph_cli-0.9.3 → swarph_cli-0.9.4}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.9.3"
-description = "The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider spawn (claude/codex/antigravity per cell.provider via a ProviderMembrane), `swarph init` (interactive cell.yaml scaffolder), `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.3 adds `swarph init` + hardens assisted_memory restore (fail-closed pull, empty-guards, codex AGENTS.md) and the mesh sidecar (no DM-loss on idle-guard)."
+version = "0.9.4"
+description = "The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider `swarph spawn` (claude/codex/antigravity per cell.provider via a ProviderMembrane + subprocess billing-scrub), interactive `swarph init`, `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.4: fixes session-pin resume across a changed cwd."
 readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.10"

{swarph_cli-0.9.3 → swarph_cli-0.9.4}/src/swarph_cli/__init__.py

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

{swarph_cli-0.9.3 → swarph_cli-0.9.4}/src/swarph_cli/cell.py

@@ -252,6 +252,42 @@ def load_cell(path: Path) -> Cell:
     return cell
 
 
+def _write_session_sidecar(target: Path, session_id: str, cwd) -> None:
+    """Write the two-line ``{uuid, cwd}`` session sidecar atomically.
+
+    v0.9.4 (session-pin cwd-mismatch fix): the sidecar records the cwd
+    the session UUID was minted for so a later spawn from a DIFFERENT
+    cwd can detect the mismatch and re-pin a fresh UUID rather than
+    handing a project-scoped UUID to ``claude --resume`` from the wrong
+    project (which dies with "No conversation found with session ID").
+
+    Format (trailing-newline convention preserved):
+
+        <uuid>\\n
+        <cwd>\\n
+    """
+    target.parent.mkdir(parents=True, exist_ok=True)
+    _atomic_write_text(target, f"{session_id}\n{str(cwd)}\n")
+
+
+def _read_session_sidecar(path: Path) -> tuple[Optional[str], Optional[str]]:
+    """Parse a session sidecar → ``(uuid, cwd)``.
+
+    Returns ``(None, None)`` for a missing/empty file. ``cwd`` is
+    ``None`` for a **legacy one-line** sidecar (bare UUID, pre-0.9.4)
+    — we cannot know which project that UUID belongs to.
+    """
+    if not path.exists():
+        return None, None
+    raw = path.read_text(encoding="utf-8")
+    lines = raw.splitlines()
+    if not lines:
+        return None, None
+    uuid_str = lines[0].strip() or None
+    cwd_str = lines[1].strip() if len(lines) >= 2 and lines[1].strip() else None
+    return uuid_str, cwd_str
+
+
 def load_or_create_session_id(
     role: str,
     cell: Cell,
@@ -266,6 +302,10 @@ def load_or_create_session_id(
       2. ``new_instance=True`` AND base sidecar exists — auto-suffix slot
       3. ``new_instance=True`` AND no base sidecar — fall through (degenerate)
       4. session_state_path(role) reused — default re-resume path
+         (v0.9.4: only when the sidecar's recorded cwd matches cell.cwd;
+         on cwd-mismatch a fresh UUID is minted + re-pinned for the new
+         cwd, because ``claude --resume`` is PROJECT-scoped and a pin
+         from another cwd dies with "No conversation found")
       5. mint new uuid4 + persist
 
     Caller-side discipline (mother iter-1 #986): the ``effective_role``
@@ -282,23 +322,33 @@ def load_or_create_session_id(
             sibling_role = next_free_slot_role(role)
             sibling_state = session_state_path(sibling_role)
             new_id = str(uuid.uuid4())
-            sibling_state.parent.mkdir(parents=True, exist_ok=True)
-            _atomic_write_text(sibling_state, new_id + "\n")
+            _write_session_sidecar(sibling_state, new_id, cell.cwd)
             return new_id, True, sibling_role
 
     state_file = session_state_path(role)
     if state_file.exists():
-        existing = state_file.read_text(encoding="utf-8").strip()
-        if existing:
+        existing_uuid, recorded_cwd = _read_session_sidecar(state_file)
+        if existing_uuid:
             try:
-                return validate_uuid_str(existing), False, role
+                valid_uuid = validate_uuid_str(existing_uuid)
             except CellError:
                 # Corrupted state — fall through and regenerate.
-                pass
+                valid_uuid = None
+            if valid_uuid is not None:
+                if recorded_cwd is not None and recorded_cwd != str(cell.cwd):
+                    # v0.9.4: pin belongs to a different project. A
+                    # project-scoped --resume would die from this cwd, so
+                    # mint a fresh (clean) UUID + re-pin for the new cwd.
+                    fresh = str(uuid.uuid4())
+                    _write_session_sidecar(state_file, fresh, cell.cwd)
+                    return fresh, True, role
+                # Legacy (recorded_cwd is None) → reuse as-is; do NOT
+                # rewrite, since the UUID's true origin cwd is unknown.
+                # Matching cwd → reuse.
+                return valid_uuid, False, role
 
     new_id = str(uuid.uuid4())
-    state_file.parent.mkdir(parents=True, exist_ok=True)
-    _atomic_write_text(state_file, new_id + "\n")
+    _write_session_sidecar(state_file, new_id, cell.cwd)
     return new_id, True, role
 
 
@@ -352,6 +402,8 @@ __all__ = [
     "read_starter_prompt",
     "load_cell",
     "load_or_create_session_id",
+    "_read_session_sidecar",
+    "_write_session_sidecar",
     # Backward-compat aliases
     "_PEER_NAME_RE",
     "_VALID_SCHEMA_VERSIONS",

{swarph_cli-0.9.3 → swarph_cli-0.9.4/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.9.3
-Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider spawn (claude/codex/antigravity per cell.provider via a ProviderMembrane), `swarph init` (interactive cell.yaml scaffolder), `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.3 adds `swarph init` + hardens assisted_memory restore (fail-closed pull, empty-guards, codex AGENTS.md) and the mesh sidecar (no DM-loss on idle-guard).
+Version: 0.9.4
+Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider `swarph spawn` (claude/codex/antigravity per cell.provider via a ProviderMembrane + subprocess billing-scrub), interactive `swarph init`, `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.4: fixes session-pin resume across a changed cwd.
 Author: Pierre Samson, Claude Opus
 License: MIT
 Project-URL: Homepage, https://github.com/darw007d/swarph-cli

{swarph_cli-0.9.3 → swarph_cli-0.9.4}/tests/test_cell_loader.py

@@ -22,6 +22,8 @@ from swarph_cli.cell import (
     load_or_create_session_id,
     resolve_cell_path,
     session_state_path,
+    _read_session_sidecar,
+    _write_session_sidecar,
 )
 
 
@@ -264,7 +266,9 @@ def test_load_or_create_session_id_mints_and_persists(
     uuid.UUID(sid1)  # raises if not a valid UUID
     sidecar = session_state_path("lab")
     assert sidecar.exists()
-    assert sidecar.read_text().strip() == sid1
+    rec_uuid, rec_cwd = _read_session_sidecar(sidecar)
+    assert rec_uuid == sid1
+    assert rec_cwd == str(cell.cwd)
 
 
 def test_load_or_create_session_id_reuses_persisted_value(
@@ -287,7 +291,102 @@ def test_load_or_create_session_id_corrupted_sidecar_regenerates(
     sid, generated, _role = load_or_create_session_id("lab", cell)
     uuid.UUID(sid)
     assert generated is True
-    assert sidecar.read_text().strip() == sid
+    rec_uuid, _rec_cwd = _read_session_sidecar(sidecar)
+    assert rec_uuid == sid
+
+
+# ---------------------------------------------------------------------------
+# v0.9.4 — session-pin cwd-mismatch fix (project-scoped --resume)
+# ---------------------------------------------------------------------------
+
+
+def test_session_sidecar_fresh_mint_writes_two_line_uuid_and_cwd(
+    isolated_xdg, cell_yaml_factory, tmp_path
+):
+    """v0.9.4 — first mint records BOTH the uuid AND the cwd (cwd=A)."""
+    cell = load_cell(cell_yaml_factory())  # cwd == tmp_path (== A)
+    sid, gen, _role = load_or_create_session_id("lab", cell)
+    assert gen is True
+    uuid.UUID(sid)
+    rec_uuid, rec_cwd = _read_session_sidecar(session_state_path("lab"))
+    assert rec_uuid == sid
+    assert rec_cwd == str(tmp_path)
+    assert rec_cwd == str(cell.cwd)
+
+
+def test_session_sidecar_same_cwd_reuses_same_uuid(
+    isolated_xdg, cell_yaml_factory, tmp_path
+):
+    """v0.9.4 — pre-pinned {uuid=U, cwd=A}; spawn from cwd=A reuses U."""
+    cell = load_cell(cell_yaml_factory())  # cwd == tmp_path (== A)
+    fixed = "550e8400-e29b-41d4-a716-446655440000"
+    _write_session_sidecar(session_state_path("lab"), fixed, str(tmp_path))
+    sid, gen, role = load_or_create_session_id("lab", cell)
+    assert sid == fixed
+    assert gen is False
+    assert role == "lab"
+
+
+def test_session_sidecar_different_cwd_mints_fresh_and_repins(
+    isolated_xdg, cell_yaml_factory, tmp_path
+):
+    """v0.9.4 REGRESSION — the bug: pin minted for cwd=A, spawn from cwd=B.
+
+    A project-scoped ``claude --resume <U>`` from B dies with
+    "No conversation found". Fix: mint a FRESH (clean) uuid and re-pin
+    it for cwd=B.
+    """
+    cwd_b = tmp_path / "project_b"
+    cwd_b.mkdir()
+    cell = load_cell(cell_yaml_factory(cwd=str(cwd_b)))  # cell.cwd == B
+    fixed = "550e8400-e29b-41d4-a716-446655440000"  # pinned for cwd=A
+    _write_session_sidecar(session_state_path("lab"), fixed, str(tmp_path))
+
+    sid, gen, role = load_or_create_session_id("lab", cell)
+    assert gen is True
+    assert sid != fixed  # genuine fresh UUID
+    uuid.UUID(sid)
+    assert role == "lab"
+    # Sidecar now re-pinned for cwd=B with the fresh UUID.
+    rec_uuid, rec_cwd = _read_session_sidecar(session_state_path("lab"))
+    assert rec_uuid == sid
+    assert rec_cwd == str(cwd_b)
+
+
+def test_session_sidecar_legacy_one_line_is_reused_not_reminted(
+    isolated_xdg, cell_yaml_factory, tmp_path
+):
+    """v0.9.4 back-compat — legacy bare-uuid (no cwd) sidecar is reused
+    as-is regardless of cwd (origin cwd unknown; do NOT re-mint)."""
+    cell = load_cell(cell_yaml_factory())
+    fixed = "550e8400-e29b-41d4-a716-446655440000"
+    sidecar = session_state_path("lab")
+    sidecar.parent.mkdir(parents=True, exist_ok=True)
+    sidecar.write_text(fixed + "\n")  # legacy one-line format
+    sid, gen, role = load_or_create_session_id("lab", cell)
+    assert sid == fixed
+    assert gen is False
+    assert role == "lab"
+    # Not upgraded/rewritten — stays legacy one-line.
+    assert sidecar.read_text() == fixed + "\n"
+
+
+def test_read_session_sidecar_parses_both_formats(tmp_path):
+    """v0.9.4 — _read_session_sidecar handles 2-line AND legacy 1-line."""
+    two_line = tmp_path / "two.session-id"
+    two_line.write_text("550e8400-e29b-41d4-a716-446655440000\n/home/x/proj\n")
+    assert _read_session_sidecar(two_line) == (
+        "550e8400-e29b-41d4-a716-446655440000",
+        "/home/x/proj",
+    )
+    one_line = tmp_path / "one.session-id"
+    one_line.write_text("550e8400-e29b-41d4-a716-446655440000\n")
+    assert _read_session_sidecar(one_line) == (
+        "550e8400-e29b-41d4-a716-446655440000",
+        None,
+    )
+    missing = tmp_path / "missing.session-id"
+    assert _read_session_sidecar(missing) == (None, None)
 
 
 def test_load_or_create_session_id_atomic_no_tempfile_left_behind(
@@ -435,8 +534,8 @@ def test_new_instance_with_existing_base_mints_into_slot_2(
     base_path = session_state_path("drop")
     sib_path = session_state_path("drop-2")
     assert base_path.exists() and sib_path.exists()
-    assert base_path.read_text().strip() == sid_base
-    assert sib_path.read_text().strip() == sid_sib
+    assert _read_session_sidecar(base_path)[0] == sid_base
+    assert _read_session_sidecar(sib_path)[0] == sid_sib
 
 
 def test_new_instance_third_call_lands_at_slot_3(

{swarph_cli-0.9.3 → swarph_cli-0.9.4}/tests/test_spawn_command.py

@@ -459,7 +459,7 @@ def test_run_spawn_new_instance_with_base_mints_sibling_slot(
 ):
     """v0.7 PR-B — `--new-instance` with base sidecar present allocates
     slot 2 AND persists. Sibling resumable via `swarph spawn <role>-2`."""
-    from swarph_cli.cell import session_state_path
+    from swarph_cli.cell import session_state_path, _read_session_sidecar
 
     # First spawn establishes base slot
     run_spawn(argv=[str(fake_cell_yaml), "--dry-run", "--print-id"])
@@ -474,8 +474,8 @@ def test_run_spawn_new_instance_with_base_mints_sibling_slot(
 
     base_sidecar = session_state_path("lab-test")
     sibling_sidecar = session_state_path("lab-test-2")
-    assert base_sidecar.read_text().strip() == base_uuid
-    assert sibling_sidecar.read_text().strip() == sibling_uuid
+    assert _read_session_sidecar(base_sidecar)[0] == base_uuid
+    assert _read_session_sidecar(sibling_sidecar)[0] == sibling_uuid
 
     # Dry-run output shows the sibling slot label
     assert "lab-test-2" in captured.err