swarph-cli 0.72.40__tar.gz → 0.72.41__tar.gz

{swarph_cli-0.72.40/src/swarph_cli.egg-info → swarph_cli-0.72.41}/PKG-INFO

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

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

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

swarph_cli-0.72.41/src/swarph_cli/commands/skunkworks.py

@@ -0,0 +1,280 @@
+"""``swarph skunkworks`` -- run the Skunkworks research pipeline on subscription lanes.
+
+Verbs: ``run``, ``status``, ``show``, ``stop``, ``decide`` (``--as CELL`` and ``--json`` on
+each, as in ``swarph board``). The pipeline itself lives in ``swarph_mesh.skunkworks``
+(swarph-mesh 0.9.1+). Ideation and the architect are jobs on the mesh queue, research is a
+local ``claude -p`` with web tools only, and nothing is metered. There is no daemon: the
+process that ran ``run`` is the run, and a killed process leaves it in ERROR.
+
+Runs are refused Monday to Friday 09:30-16:00 America/New_York (no holiday calendar).
+Approval produces no code. ``decide`` has no override: it calls ``Pipeline.approve`` and
+prints the gate's refusal when the architect did not say APPROVED_FOR_BUILD.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Callable, Optional
+
+from swarph_cli.commands._display import sanitize_terminal as _s
+from swarph_cli.commands.board import (
+    _card_say_payload,
+    _project_owner_orchestrator,
+    _thread_recipient,
+)
+from swarph_cli.commands.mesh import (
+    _add_common,
+    _http_get_json,
+    _post_json,
+    _resolve_self_name,
+    _resolve_token,
+)
+
+# MessagePostRequest.content max_length (gateway server.py), used by POST /messages, which
+# is the route `swarph board cards say` posts a card message through.
+CARD_POST_LIMIT = 200_000
+NEEDS_MESH = ("swarph skunkworks: needs swarph-mesh 0.9.x with skunkworks "
+              "(pip install -U 'swarph-mesh>=0.9.1,<0.10')")
+
+PostCard = Callable[[int, str, str], None]  # (card_id, kind, content); raises on failure
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="swarph skunkworks", description=__doc__)
+    sub = p.add_subparsers(dest="command", required=True)
+
+    r = sub.add_parser("run", help="start a run in this process (refused 09:30-16:00 New York, weekdays)")
+    r.add_argument("--card", type=int, required=True, help="board card the run reports to")
+    r.add_argument("--persona", required=True, help="persona pack name, e.g. swarph")
+    r.add_argument("--seed-file", required=True, help="file holding the seed")
+    r.add_argument("--blocker-question-file", default=None)
+    r.add_argument("--context-file", action="append", default=[],
+                   help="shown to the architect only; repeatable")
+
+    s = sub.add_parser("status", help="state of a run")
+    s.add_argument("run_id")
+    w = sub.add_parser("show", help="print a run's stage outputs")
+    w.add_argument("run_id")
+    w.add_argument("--stage", choices=["ideation", "research", "architecture"], default=None)
+    t = sub.add_parser("stop", help="write the STOP file; checked before each job")
+    t.add_argument("run_id")
+    d = sub.add_parser("decide", help="record the commander's decision (no override exists)")
+    d.add_argument("run_id")
+    d.add_argument("verdict", help="APPROVED, REJECTED or REVISE")
+    d.add_argument("--quote-file", required=True,
+                   help="file holding the commander's own words, posted to the card")
+    for sp in (r, s, w, t, d):
+        sp.add_argument("--json", action="store_true")
+        _add_common(sp)
+    return p
+
+
+def _cut(text: str, path: str, limit: int = CARD_POST_LIMIT) -> str:
+    if len(text) <= limit:
+        return text
+    note = f"\n[cut at {limit} characters; full text at {path}]"
+    return text[: max(limit - len(note), 0)] + note
+
+
+def _default_post_card(gw: str, token: str, cell: str, opt_out: bool) -> PostCard:
+    """Post onto the card's thread the way ``swarph board cards say`` does."""
+    def post(card_id: int, kind: str, content: str) -> None:
+        st, card = _http_get_json(f"{gw}/board/cards/{card_id}", token)
+        if st != 200:
+            raise RuntimeError(f"cannot read card #{card_id}: {card.get('detail', card)}")
+        thread = card.get("thread_uuid")
+        if not thread:
+            raise RuntimeError(f"card #{card_id} has no bound thread")
+        owner = None
+        if not card.get("assignee"):
+            owner = _project_owner_orchestrator(gw, token, card.get("project_id"))
+        to_node, _ = _thread_recipient(card, None, owner_orchestrator=owner)
+        st, d = _post_json(f"{gw}/messages",
+                           _card_say_payload(cell, to_node, kind, content, thread, opt_out=opt_out),
+                           token)
+        if not (st and 200 <= st < 300):
+            raise RuntimeError(f"card post refused, HTTP {st or 'unreachable'}: {d.get('detail', d)}")
+    return post
+
+
+def _read(path: str, what: str) -> str:
+    try:
+        text = Path(path).read_text(encoding="utf-8")
+    except OSError as exc:
+        raise ValueError(f"cannot read {what} {path!r}: {exc}") from None
+    return text
+
+
+def _emit(obj: dict, as_json: bool, line: str) -> None:
+    print(json.dumps(obj, indent=2) if as_json else line)
+
+
+def _summary(st) -> dict:
+    return {"run_id": st.run_id, "status": st.status.value, "jobs_used": st.jobs_used,
+            "jobs_max": 10, "card_id": st.card_id, "error": st.error,
+            "cut_queries": len(st.cut_queries),
+            "ideation": st.ideation is not None, "research": st.research is not None,
+            "architecture": st.architecture is not None,
+            "commander_verdict": st.commander_verdict}
+
+
+def run_skunkworks(
+    argv: list[str],
+    *,
+    post_card: Optional[PostCard] = None,
+    runners_factory=None,
+    now=None,
+    state_root: Optional[Path] = None,
+    persona_dir: Optional[str] = None,
+) -> int:
+    try:  # an older swarph-mesh has no skunkworks: say so in one line
+        from swarph_mesh import skunkworks as sk
+        from swarph_mesh.skunkworks import artifacts, ceilings, service
+    except ImportError:
+        print(NEEDS_MESH, file=sys.stderr)
+        return 1
+
+    args = _build_parser().parse_args(argv)
+    aj = args.json
+    try:
+        cell = _resolve_self_name(args.self_name)
+    except RuntimeError as exc:
+        print(f"swarph skunkworks: {exc}", file=sys.stderr)
+        return 1
+    rdir = ceilings.runs_dir_for(cell, state_root)
+
+    if args.command == "run":
+        return _run(args, cell, rdir, sk, service, ceilings, post_card, runners_factory,
+                    now, state_root, persona_dir, aj)
+
+    if not service.RUN_ID_RE.match(args.run_id):
+        print(f"swarph skunkworks: bad run id {args.run_id!r}", file=sys.stderr)
+        return 1
+    run_path = rdir / args.run_id
+    raw = artifacts.read_json(str(run_path / "state.json"))
+    if not isinstance(raw, dict):
+        print(f"swarph skunkworks: no run {args.run_id} for cell {cell} under {rdir}", file=sys.stderr)
+        return 1
+    if args.command == "status":
+        service.sweep_dead_runs(rdir)  # a killed run shows as ERROR, not as still running
+        raw = artifacts.read_json(str(run_path / "state.json")) or raw
+    st = sk.RunState.from_dict(raw)
+
+    if args.command == "status":
+        sm = _summary(st)
+        _emit(sm, aj, f"{sm['run_id']}  {sm['status']}  jobs {sm['jobs_used']}/{sm['jobs_max']}"
+              + (f"  error: {_s(sm['error'])}" if sm["error"] else ""))
+        return 0
+
+    if args.command == "show":
+        names = [args.stage] if args.stage else list(artifacts.RUN_FILES)
+        out = {n: artifacts.read_json(str(run_path / artifacts.RUN_FILES[n])) for n in names}
+        if all(v is None for v in out.values()):
+            print(f"swarph skunkworks: nothing to show yet for {args.run_id} ({st.status.value})",
+                  file=sys.stderr)
+            return 1
+        print(json.dumps(out if not args.stage else out[args.stage], indent=2))
+        return 0
+
+    if args.command == "stop":
+        stop = run_path / "STOP"
+        stop.write_text("stop requested\n")
+        _emit({"run_id": args.run_id, "stop_file": str(stop)}, aj, f"wrote {stop}")
+        return 0
+
+    return _decide(args, cell, st, rdir, sk, post_card, aj)
+
+
+def _run(args, cell, rdir, sk, service, ceilings, post_card, runners_factory, now,
+         state_root, persona_dir, aj) -> int:
+    try:
+        seed = _read(args.seed_file, "seed file").strip()
+        blocker = (_read(args.blocker_question_file, "blocker file").strip()
+                   if args.blocker_question_file else None)
+        ctx = [str(Path(p).resolve()) for p in args.context_file]
+        for p in ctx:
+            _read(p, "context file")
+        if not seed:
+            raise ValueError("the seed file is empty; a run needs a seed")
+        request = sk.SkunkworksRequest(requesting_swarm=cell, persona=args.persona, seed=seed,
+                                       card_id=args.card, blocker_question=blocker or None,
+                                       context_md_paths=ctx)
+        gw = args.gateway.rstrip("/")
+        token = _resolve_token(cell, args.token_file)
+    except (ValueError, RuntimeError) as exc:
+        print(f"swarph skunkworks run: {exc}", file=sys.stderr)
+        return 1
+
+    post_card = post_card or _default_post_card(gw, token, cell, args.no_redact)
+    if runners_factory is None:
+        runners_factory = service.default_runners(
+            gateway_url=gw, cell=cell,
+            post=lambda url, body: _post_json(url, body, token),
+            get=lambda url: _http_get_json(url, token))
+
+    def post(kind: str, content: str) -> None:
+        try:
+            post_card(args.card, kind, content)
+        except Exception as exc:  # the run goes on; the artifacts are on disk
+            print(f"swarph skunkworks: card post failed: {_s(str(exc))}", file=sys.stderr)
+
+    def on_stage(st, stage: str) -> None:
+        post("status", json.dumps({"type": "skunkworks_status", "run_id": st.run_id,
+                                   "stage": stage, "status": st.status.value,
+                                   "jobs_used": st.jobs_used, "jobs_max": 10,
+                                   "error": st.error}, sort_keys=True))
+        path = rdir / st.run_id
+        if stage == "ideation":
+            post("fyi", _cut(f"skunkworks ideation, run {st.run_id}\n"
+                             + json.dumps(st.ideation, indent=2), str(path / "ideation.json")))
+        elif stage == "architecture":
+            post("fyi", _cut(f"skunkworks architecture, run {st.run_id}\n"
+                             + json.dumps(st.architecture, indent=2), str(path / "architecture.json")))
+
+    kw = {"now": now} if now else {}
+    try:
+        st = service.start_run(request, runners_factory=runners_factory, state_root=state_root,
+                               persona_dir=persona_dir, on_stage=on_stage, **kw)
+    except ceilings.RunRefused as exc:
+        print(f"swarph skunkworks run: {exc}", file=sys.stderr)
+        return 1
+    except (ValueError, FileNotFoundError) as exc:  # unknown persona
+        print(f"swarph skunkworks run: {exc}", file=sys.stderr)
+        return 1
+    sm = _summary(st)
+    _emit(sm, aj, f"{sm['run_id']}  {sm['status']}  jobs {sm['jobs_used']}/{sm['jobs_max']}"
+          + (f"  error: {_s(sm['error'])}" if sm["error"] else ""))
+    return 0 if sm["status"] == "awaiting_commander" else 1
+
+
+def _decide(args, cell, st, rdir, sk, post_card, aj) -> int:
+    try:
+        quote = _read(args.quote_file, "quote file").strip()
+    except ValueError as exc:
+        print(f"swarph skunkworks decide: {exc}", file=sys.stderr)
+        return 1
+    if not quote:
+        print("swarph skunkworks decide: the quote file is empty; decide records the "
+              "commander's own words", file=sys.stderr)
+        return 1
+    res = sk.Pipeline(runs_dir=str(rdir)).approve(st, args.verdict, notes=quote)
+    if "error" in res:  # the gate's refusal dict, or a bad verdict / wrong status
+        print(json.dumps(res, indent=2))
+        return 1
+    try:
+        gw = args.gateway.rstrip("/")
+        post_card = post_card or _default_post_card(
+            gw, _resolve_token(cell, args.token_file), cell, args.no_redact)
+        post_card(st.card_id, "status",
+                  f"skunkworks decision, run {st.run_id}: {res['status']} "
+                  f"(architect verdict {res['arch_verdict_at_decision'] or 'MISSING'}).\n"
+                  f"Commander's words, quoted from {args.quote_file}:\n{quote}")
+    except Exception as exc:
+        print(f"swarph skunkworks decide: recorded locally, card post failed: {_s(str(exc))}",
+              file=sys.stderr)
+        _emit(res, aj, f"{res['run_id']}  {res['status']}")
+        return 2
+    _emit(res, aj, f"{res['run_id']}  {res['status']}")
+    return 0

{swarph_cli-0.72.40 → swarph_cli-0.72.41}/src/swarph_cli/guide/GUIDE.md

@@ -51,6 +51,8 @@ want, run the command.
 | keep my memory from rotting between sessions | `swarph dreaming run --corpus <dir> --out <dir>` |
 | find out who calls a function | `swarph codegraph <symbol>` |
 | find out what happened and when | `swarph timeline around <date>` |
+| run a research pipeline on subscription lanes | `swarph skunkworks run --card <N> --persona swarph --seed-file <path> --as <you>` |
+| see how a pipeline run is doing | `swarph skunkworks status <run_id> --as <you>` |
 | check whether my setup is right | see [Check your own setup](#check-your-own-setup) |
 | get woken when a DM arrives | `swarph install-wake-hook --scope project` |
 | see what a wake hook would print | `swarph wake-hook-output` |
@@ -558,6 +560,7 @@ answers `--help`; hook-plumbing verbs are the callbacks hooks invoke, not comman
 - `swarph scan` -- statically scan an artifact for dangerous patterns before publish.
 - `swarph schedule` -- the gateway's scheduled events: create, list, get, enable, disable, delete, fire-now.
 - `swarph service` -- stand up a $0 subscription-LLM HTTP lane.
+- `swarph skunkworks` -- the research pipeline (card #1405): `run`, `status`, `show`, `stop`, `decide`, each with `--as <you>` and `--json`. Ideation and the architect run on the mesh queue, research on the requesting cell's own Claude quota, nothing metered. Refused Monday to Friday 09:30-16:00 New York time. Approval produces no code. See `docs/skunkworks-howto.md` in the swarph-cli repo.
 - `swarph spawn` -- run a cell from its role name or yaml path.
 - `swarph sweep` -- the card-#1064 stuck-work sweep: blocked rows and unreviewed PRs, DMs the blocker, `swarph sweep --dry-run` reads only.
 - `swarph triage` -- the card-#1073 organ triage router: sensor findings onto owner triage rows (cap 10, carried), `swarph triage --dry-run` reads only.

{swarph_cli-0.72.40 → swarph_cli-0.72.41}/src/swarph_cli/main.py

@@ -108,6 +108,8 @@ _VERB_HANDLERS: dict[str, str] = {
     "peer-reply-drain": "swarph_cli.commands.peer_reply_drain.run_peer_reply_drain",
     "monitor": "swarph_cli.commands.monitor.run_monitor",
     "board": "swarph_cli.commands.board.run_board",
+    # card #1405: research pipeline on subscription lanes (library: swarph_mesh.skunkworks).
+    "skunkworks": "swarph_cli.commands.skunkworks.run_skunkworks",
     # card #1297: propose a decision or an action. The commander decides.
     "commander": "swarph_cli.commands.commander.run_commander",
     "group": "swarph_cli.commands.group.run_group",

{swarph_cli-0.72.40 → swarph_cli-0.72.41/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.40
+Version: 0.72.41
 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.40 → swarph_cli-0.72.41}/src/swarph_cli.egg-info/SOURCES.txt

@@ -127,6 +127,7 @@ src/swarph_cli/commands/rowclear_hook.py
 src/swarph_cli/commands/schedule.py
 src/swarph_cli/commands/security.py
 src/swarph_cli/commands/service.py
+src/swarph_cli/commands/skunkworks.py
 src/swarph_cli/commands/spawn.py
 src/swarph_cli/commands/sweep.py
 src/swarph_cli/commands/timeline.py
@@ -275,6 +276,9 @@ tests/test_1385_duplicate_session_argv.py
 tests/test_138_memory_navigate.py
 tests/test_1396_dev_extract.py
 tests/test_139_tool_probe.py
+tests/test_1405_skunkworks_basic.py
+tests/test_1405_skunkworks_cli.py
+tests/test_1427_membrane_workflow.py
 tests/test_183_card_anchor.py
 tests/test_184_notify_honesty.py
 tests/test_201_win32_bash_refusal.py

swarph_cli-0.72.41/tests/test_1405_skunkworks_basic.py

@@ -0,0 +1,86 @@
+"""Card #1405: the parts of ``swarph skunkworks`` that need no swarph-mesh skunkworks library.
+
+These run against the swarph-mesh a fresh install resolves (the pin allows 0.9.0, which has
+no skunkworks package), so they stay green before 0.9.1 ships. The tests that run a pipeline
+are in test_1405_skunkworks_cli.py and skip until swarph-mesh >= 0.9.1 is installed.
+"""
+import ast
+import sys
+from pathlib import Path
+
+import pytest
+
+from swarph_cli.commands import skunkworks as cli
+
+_ROOT = Path(__file__).resolve().parents[1]
+_DOCS = {"howto": _ROOT / "docs" / "skunkworks-howto.md",
+         "guide": _ROOT / "src" / "swarph_cli" / "guide" / "GUIDE.md"}
+
+
+def test_verb_is_registered():
+    from swarph_cli.main import _VERB_HANDLERS
+    assert _VERB_HANDLERS["skunkworks"] == "swarph_cli.commands.skunkworks.run_skunkworks"
+    assert callable(cli.run_skunkworks)
+
+
+def test_old_swarph_mesh_gets_a_one_line_message(monkeypatch, capsys):
+    monkeypatch.setitem(sys.modules, "swarph_mesh.skunkworks", None)
+    assert cli.run_skunkworks(["status", "sk_1_abcd1234", "--as", "x"]) == 1
+    err = capsys.readouterr().err
+    assert err.count("\n") == 1 and "needs swarph-mesh 0.9.x with skunkworks" in err
+
+
+def test_cut_leaves_short_text_alone():
+    assert cli._cut("abc", "/p") == "abc"
+    cut = cli._cut("a" * 500, "/p", limit=100)
+    assert len(cut) == 100 and cut.startswith("aaa") and cut.endswith("full text at /p]")
+
+
+def test_decide_has_no_override_in_the_parser_or_the_source():
+    """Clause 9. Mutation: add an --override flag to decide -> the parser check fails."""
+    p = cli._build_parser()
+    opts = {o for sp in p._subparsers._group_actions[0].choices.values()
+            for a in sp._actions for o in a.option_strings}
+    assert not [o for o in opts if "override" in o.lower()], opts
+    with pytest.raises(SystemExit):
+        cli._build_parser().parse_args(["decide", "sk_1_abcd1234", "APPROVED", "--quote-file",
+                                        "q", "--override", "--as", "x"])
+    tree = ast.parse(Path(cli.__file__).read_text())
+    names = [n.id for n in ast.walk(tree) if isinstance(n, ast.Name)] + \
+            [n.arg for n in ast.walk(tree) if isinstance(n, (ast.arg, ast.keyword)) and n.arg] + \
+            [n.attr for n in ast.walk(tree) if isinstance(n, ast.Attribute)]
+    assert not [n for n in names if "override" in n.lower()]
+
+
+def test_default_card_post_uses_the_board_say_path(monkeypatch):
+    calls = []
+
+    def get(url, token, **kw):
+        calls.append(("GET", url))
+        return 200, {"thread_uuid": "T-1", "assignee": "peer-b", "id": 7}
+
+    def post(url, body, token, **kw):
+        calls.append(("POST", url, body))
+        return 200, {"id": 1}
+    monkeypatch.setattr(cli, "_http_get_json", get)
+    monkeypatch.setattr(cli, "_post_json", post)
+    cli._default_post_card("http://gw.invalid", "tok", "cell-a", False)(7, "status", "hello")
+    assert calls[0] == ("GET", "http://gw.invalid/board/cards/7")
+    _, url, body = calls[1]
+    assert url == "http://gw.invalid/messages"
+    assert body == {"from_node": "cell-a", "to_node": "peer-b", "kind": "status",
+                    "content": "hello", "thread_id": "T-1"}
+    monkeypatch.setattr(cli, "_post_json", lambda *a, **k: (403, {"detail": "no grant"}))
+    with pytest.raises(RuntimeError, match="403"):
+        cli._default_post_card("http://gw.invalid", "tok", "cell-a", False)(7, "status", "x")
+
+
+@pytest.mark.parametrize("name", ["howto", "guide"])
+def test_docs_name_commands_window_billing_and_no_code(name):
+    text = _DOCS[name].read_text(encoding="utf-8")
+    low = text.lower()
+    for verb in ("run", "status", "show", "stop", "decide"):
+        assert f"swarph skunkworks {verb}" in text or f"`{verb}`" in text, (name, verb)
+    assert "09:30-16:00" in text and "new york" in low
+    assert "claude quota" in low and "queue" in low
+    assert "produces no code" in low