swarph-cli 0.10.0__tar.gz → 0.10.2__tar.gz

{swarph_cli-0.10.0/src/swarph_cli.egg-info → swarph_cli-0.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.10.0
+Version: 0.10.2
 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.5: foolproof Windows auto-relaunch (genuine-WT detection via process ancestry, not WT_SESSION).
 Author: Pierre Samson, Claude Opus
 License: MIT
@@ -348,6 +348,58 @@ Pong!
 # 3+26t  $0.0000  0.73s  caller=cli.oneshot.ubuntu  provider=gemini
 ```
 
+### `swarph compress` (v0.11 — context-surface compression)
+
+Compress a **machine-read context surface** (memory index, manual, agent brief) to
+reclaim always-loaded space/tokens. The principle: fluent natural language carries
+redundancy a model infers for free — *the decompressor is the model itself*. Proven
+by hand on the OMEGA swarm: `MEMORY.md` 37→16KB (58%), `CLAUDE.md` 241→21KB
+always-loaded (91%, archival).
+
+**Opt-in by marker (fails safe).** A file is compressible only if it carries an
+explicit marker; unmarked files are left untouched. The model's judgment is spent
+once, in-session, authoring the marker — runtime is pure-Python marker parsing, no
+model in the hot path.
+
+```
+<!-- swarph:compress lever=archival boundary="^## Session" -->
+<!-- swarph:compress lever=shorthand pointer="](*.md)" floor=0.45 -->
+```
+
+**Two levers, different risk classes:**
+
+| Lever | What | Loss class | Model? |
+|---|---|---|---|
+| `archival` | relocate the cold tail below `boundary` to `<file>.archive.<ext>` + leave a pointer | **lossless** (nothing destroyed) | no — pure Python, zero tokens |
+| `shorthand` | rewrite a pointer-bearing INDEX to telegraphic shorthand | lossy, **bounded to index-over-preserved-source** (recoverable by construction) | yes (`claude -p` subscription path) |
+
+Shorthand is gated: redundancy-floor (refuse if already dense), links-superset
+(every `[]()` survives), index-over-source (every entry keeps a resolvable
+pointer), and an **adversarial verify-expand** (an independent model hunts for a
+dropped fact; one found → abort).
+
+```bash
+swarph compress MEMORY.md                      # dry-run: classify, propose, report savings
+swarph compress MEMORY.md --apply              # write (atomic tempfile→mv + .bak + verify-gate)
+swarph compress MEMORY.md --verify-idempotent  # assert compress(compress(x)) ≈ noop
+```
+
+Dry-run is the default — nothing mutates without `--apply`. Cron-friendly exit codes:
+
+| Code | Meaning |
+|---|---|
+| `0` | analyzed/savings-reported (or applied clean) |
+| `2` | no such file |
+| `3` | refused — unmarked (leave breathing) |
+| `4` | refused — archival: no boundary line matched |
+| `5` | refused — shorthand: below redundancy floor (already dense) |
+| `6` | refused — shorthand dropped a link / lost a pointer-to-source |
+| `7` | refused — adversarial verify-expand found a dropped fact |
+| `8` | refused — not idempotent (second pass kept cutting; signal-eating alarm) |
+
+Design spec: `docs/superpowers/specs/2026-06-11-swarph-context-compressor-design.md`
+(in the hedge-fund-mcp repo).
+
 ### `--json` mode semantics
 
 `--json` is a **harness trigger**, not a strict-validation gate. When set, swarph routes the response through the swarph-mesh JSON harness:

{swarph_cli-0.10.0 → swarph_cli-0.10.2}/README.md

@@ -313,6 +313,58 @@ Pong!
 # 3+26t  $0.0000  0.73s  caller=cli.oneshot.ubuntu  provider=gemini
 ```
 
+### `swarph compress` (v0.11 — context-surface compression)
+
+Compress a **machine-read context surface** (memory index, manual, agent brief) to
+reclaim always-loaded space/tokens. The principle: fluent natural language carries
+redundancy a model infers for free — *the decompressor is the model itself*. Proven
+by hand on the OMEGA swarm: `MEMORY.md` 37→16KB (58%), `CLAUDE.md` 241→21KB
+always-loaded (91%, archival).
+
+**Opt-in by marker (fails safe).** A file is compressible only if it carries an
+explicit marker; unmarked files are left untouched. The model's judgment is spent
+once, in-session, authoring the marker — runtime is pure-Python marker parsing, no
+model in the hot path.
+
+```
+<!-- swarph:compress lever=archival boundary="^## Session" -->
+<!-- swarph:compress lever=shorthand pointer="](*.md)" floor=0.45 -->
+```
+
+**Two levers, different risk classes:**
+
+| Lever | What | Loss class | Model? |
+|---|---|---|---|
+| `archival` | relocate the cold tail below `boundary` to `<file>.archive.<ext>` + leave a pointer | **lossless** (nothing destroyed) | no — pure Python, zero tokens |
+| `shorthand` | rewrite a pointer-bearing INDEX to telegraphic shorthand | lossy, **bounded to index-over-preserved-source** (recoverable by construction) | yes (`claude -p` subscription path) |
+
+Shorthand is gated: redundancy-floor (refuse if already dense), links-superset
+(every `[]()` survives), index-over-source (every entry keeps a resolvable
+pointer), and an **adversarial verify-expand** (an independent model hunts for a
+dropped fact; one found → abort).
+
+```bash
+swarph compress MEMORY.md                      # dry-run: classify, propose, report savings
+swarph compress MEMORY.md --apply              # write (atomic tempfile→mv + .bak + verify-gate)
+swarph compress MEMORY.md --verify-idempotent  # assert compress(compress(x)) ≈ noop
+```
+
+Dry-run is the default — nothing mutates without `--apply`. Cron-friendly exit codes:
+
+| Code | Meaning |
+|---|---|
+| `0` | analyzed/savings-reported (or applied clean) |
+| `2` | no such file |
+| `3` | refused — unmarked (leave breathing) |
+| `4` | refused — archival: no boundary line matched |
+| `5` | refused — shorthand: below redundancy floor (already dense) |
+| `6` | refused — shorthand dropped a link / lost a pointer-to-source |
+| `7` | refused — adversarial verify-expand found a dropped fact |
+| `8` | refused — not idempotent (second pass kept cutting; signal-eating alarm) |
+
+Design spec: `docs/superpowers/specs/2026-06-11-swarph-context-compressor-design.md`
+(in the hedge-fund-mcp repo).
+
 ### `--json` mode semantics
 
 `--json` is a **harness trigger**, not a strict-validation gate. When set, swarph routes the response through the swarph-mesh JSON harness:

{swarph_cli-0.10.0 → swarph_cli-0.10.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.10.0"
+version = "0.10.2"
 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.5: foolproof Windows auto-relaunch (genuine-WT detection via process ancestry, not WT_SESSION)."
 readme = "README.md"
 license = { text = "MIT" }

{swarph_cli-0.10.0 → swarph_cli-0.10.2}/src/swarph_cli/__init__.py

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

swarph_cli-0.10.2/src/swarph_cli/commands/compress.py

@@ -0,0 +1,80 @@
+"""`swarph compress <file>` — compress a machine-read surface. Dry-run by default;
+marker opt-in (unmarked -> refuse). See docs spec 2026-06-11-swarph-context-compressor."""
+from __future__ import annotations
+import argparse, asyncio, shutil, sys, tempfile, os
+from pathlib import Path
+from ..compress.marker import parse_marker
+from ..compress.levers import archival_split, shorthand
+from ..compress import verify
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="swarph compress", description="Compress a machine-read context surface.")
+    p.add_argument("file", help="path to the surface to compress")
+    p.add_argument("--apply", action="store_true", help="write changes (default: dry-run)")
+    p.add_argument("--verify-idempotent", action="store_true", help="assert compress(compress(x)) ~= noop")
+    p.add_argument("--force", action="store_true", help="override refusals (NOT for source-of-truth)")
+    return p
+
+
+def _atomic_write(path: Path, content: str) -> None:
+    shutil.copy2(path, path.with_suffix(path.suffix + ".bak"))
+    fd, tmp = tempfile.mkstemp(dir=str(path.parent), suffix=".tmp")
+    with os.fdopen(fd, "w") as fh:
+        fh.write(content)
+    os.replace(tmp, path)
+
+
+def run_compress(argv: list[str]) -> int:
+    args = _build_parser().parse_args(argv)
+    path = Path(args.file)
+    if not path.exists():
+        print(f"[compress] no such file: {path}", file=sys.stderr)
+        return 2
+    source = path.read_text()
+    marker = parse_marker(source)
+    if marker is None:
+        print(f"[compress] REFUSE: {path} carries no swarph:compress marker — leaving untouched", file=sys.stderr)
+        return 3
+
+    if marker.lever == "archival":
+        archive_path = path.with_suffix(".archive" + path.suffix)
+        res = archival_split(source, boundary=marker.boundary, archive_name=archive_path.name)
+        if res is None:
+            print(f"[compress] REFUSE: no boundary line matching {marker.boundary!r}", file=sys.stderr)
+            return 4
+        saved = len(source) - len(res.live)
+        print(f"[compress] archival: {path.name} {len(source)}B → {len(res.live)}B live "
+              f"(+{len(res.archive)}B → {archive_path.name}); saved {saved}B always-loaded")
+        if args.apply:
+            archive_path.write_text(res.archive)
+            _atomic_write(path, res.live)
+            print(f"[compress] applied (.bak left, archive {archive_path.name})")
+        return 0
+
+    # shorthand
+    floor = marker.floor if marker.floor is not None else 0.45
+    if not verify.above_floor(source, floor):
+        print(f"[compress] REFUSE: already dense (below redundancy floor {floor}) — nothing free to remove", file=sys.stderr)
+        return 5
+    out = asyncio.run(shorthand(source))
+    if not verify.links_preserved(source, out):
+        print("[compress] REFUSE: shorthand dropped a link (links not superset)", file=sys.stderr)
+        return 6
+    if not verify.entries_point_to_source(out, pointer=marker.pointer, base=path.parent):
+        print("[compress] REFUSE: an entry lost its pointer-to-source (index-over-source violated)", file=sys.stderr)
+        return 6
+    if not asyncio.run(verify.verify_expand(source, out)):
+        print("[compress] REFUSE: adversarial verify-expand found a dropped fact", file=sys.stderr)
+        return 7
+    if args.verify_idempotent:
+        out2 = asyncio.run(shorthand(out))
+        if not verify.idempotent(out, out2):
+            print("[compress] REFUSE: not idempotent — second pass kept cutting (signal-eating alarm)", file=sys.stderr)
+            return 8
+    saved = len(source) - len(out)
+    print(f"[compress] shorthand: {path.name} {len(source)}B → {len(out)}B; saved {saved}B ({saved*100//max(len(source),1)}%)")
+    if args.apply:
+        _atomic_write(path, out)
+        print("[compress] applied (.bak left)")
+    return 0

{swarph_cli-0.10.0 → swarph_cli-0.10.2}/src/swarph_cli/commands/init.py

@@ -139,7 +139,15 @@ def run_init(argv: list[str]) -> int:
     cwd_raw = args.cwd or (_ask("Working dir (cwd)", str(Path.cwd())) if interactive else str(Path.cwd()))
     cwd = Path(cwd_raw).expanduser().resolve()
     tmux = args.tmux or (_ask("tmux session", name) if interactive else name)
-    cursor = args.cursor or f"/tmp/{name}-cursor.json"
+    # Default MUST match where `swarph mesh sidecar` actually writes its
+    # cursor (<state-dir>/cursor.json, state-dir defaulting to
+    # ~/swarph_state/<name>/mesh-sidecar) — the watchdog reads THIS pin while
+    # the sidecar maintains THAT file. The old /tmp default left the two
+    # shipped components pointing at different paths out of the box
+    # (science-claude onboarding, 2026-06-10).
+    cursor = args.cursor or str(
+        Path.home() / "swarph_state" / name / "mesh-sidecar" / "cursor.json"
+    )
 
     # ── sandbox ──
     if provider == "codex":