swarph-cli 0.2.0__tar.gz → 0.3.0__tar.gz

{swarph_cli-0.2.0/src/swarph_cli.egg-info → swarph_cli-0.3.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.2.0
-Summary: The `swarph` binary — multi-LLM CLI with mesh-gateway integration. Phase 2 one-shot mode shipped (PLAN.md §13).
+Version: 0.3.0
+Summary: The `swarph` binary — multi-LLM CLI with mesh-gateway integration. v0.3.0 ships the Phase 5 `swarph chat` REPL on top of Phase 2 one-shot + Phase 2.5 import (PLAN.md §13).
 Author: Pierre Samson, Claude Opus
 License: MIT
 Project-URL: Homepage, https://github.com/darw007d/swarph-cli
@@ -24,7 +24,7 @@ Classifier: Topic :: Utilities
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: swarph-mesh>=0.1.0
+Requires-Dist: swarph-mesh>=0.5.0
 Requires-Dist: swarph-shared>=0.2.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
@@ -49,12 +49,52 @@ This is one of three repos in the v0.3.x architecture:
 
 ## Status
 
-**v0.2.0 — Phase 2 one-shot + Phase 2.5 import.** Two verbs ship:
+**v0.3.0 — Phase 2 one-shot + Phase 2.5 import + Phase 5 REPL.** Three verbs ship:
 
-1. `swarph "prompt"` — Phase 2 one-shot mode (against `--provider gemini`)
-2. `swarph import <path>` — Phase 2.5 session import (Claude JSONL → swarph-native, with `--report-only` for honest pre-commit inspection)
+1. `swarph "prompt"` — Phase 2 one-shot mode (any of five providers)
+2. `swarph chat` — Phase 5 interactive REPL with multi-turn history + slash commands
+3. `swarph import <path>` — Phase 2.5 session import (Claude JSONL → swarph-native, with `--report-only` for honest pre-commit inspection)
 
-Subsequent phases extend the CLI surface (REPL, `--ask <peer>`, onboard/ratify, daemon, additional source formats).
+Subsequent phases extend the CLI surface (`--ask <peer>`, onboard/ratify, daemon, additional source formats).
+
+### `swarph chat`
+
+Interactive REPL against any of the five swarph-mesh adapters (`gemini` / `deepseek` / `claude` / `openai` / `grok`). Multi-turn conversation history accumulates in-memory; cumulative session cost + token totals tracked.
+
+```bash
+$ swarph chat --provider claude
+swarph chat — Phase 5 REPL
+provider=claude model=(adapter default) caller=cli.repl.ubuntu
+
+Type a message and press Enter to send. Slash commands:
+  /help  /clear  /system  /provider  /model  /history  /cost  /quit
+Ctrl-D to exit.
+
+> hello
+Hi! How can I help...
+# 8+12t  $0  0.34s
+
+> /provider gemini
+[switched to provider=gemini; model reset to adapter default; history cleared]
+
+> /cost
+[turns=1  in=8  out=12  cost=$0]
+
+> /quit
+[swarph-chat] bye.
+```
+
+**Slash commands:**
+- `/help` — print available commands
+- `/quit`, `/exit` (or Ctrl-D) — exit
+- `/clear`, `/reset` — clear history (keeps system prompt)
+- `/system [prompt]` — set or clear system prompt
+- `/provider <name>` — switch provider (resets history)
+- `/model <name>` — switch model
+- `/history` — print running message list
+- `/cost` — cumulative session cost + tokens
+
+**Out of scope until Phase 5.6** (`swarph daemon`): inbox drain coroutine, `/inbox` and `/reply` slash commands. Streaming output ships alongside the cross-adapter `stream()` work in v0.5+ of swarph-mesh.
 
 ### `swarph import`
 
@@ -115,13 +155,14 @@ Pong!
 
 | Phase | What lands |
 |---|---|
-| **0** (this) | Scaffold — entry-point + status banner |
-| **2** | One-shot mode: `swarph "hello" --provider gemini` |
+| **0** | Scaffold — entry-point + status banner |
+| **2** (v0.1.0) | One-shot mode: `swarph "hello" --provider gemini` |
+| **2.5** (v0.2.0) | `swarph import` — Claude JSONL → swarph-native session format |
+| **5** (v0.3.0 — this release) | **`swarph chat` interactive REPL** — multi-turn against any of five adapters + slash commands (`/help`, `/clear`, `/system`, `/provider`, `/model`, `/history`, `/cost`, `/quit`) |
 | **3** | `--ask <peer>` mesh-aware one-shot via MeshClient |
-| **5** | Interactive REPL — `/inbox`, `/reply`, `/dm`, `/watch` |
 | **5.5** | `swarph onboard <peer-name>` + `swarph ratify <peer-name>` (PLAN.md §15) |
-| **5.7** | `swarph daemon` foreground drain loop + `swarph chat` REPL with drain coroutine (PLAN.md §16) |
-| **6** | PyPI publish |
+| **5.6** | `swarph daemon` foreground drain loop + REPL drain coroutine + `/inbox`, `/reply` (PLAN.md §16) |
+| **6** | (already done) PyPI publish |
 
 ## Why split CLI from substrate
 

{swarph_cli-0.2.0 → swarph_cli-0.3.0}/README.md

@@ -17,12 +17,52 @@ This is one of three repos in the v0.3.x architecture:
 
 ## Status
 
-**v0.2.0 — Phase 2 one-shot + Phase 2.5 import.** Two verbs ship:
+**v0.3.0 — Phase 2 one-shot + Phase 2.5 import + Phase 5 REPL.** Three verbs ship:
 
-1. `swarph "prompt"` — Phase 2 one-shot mode (against `--provider gemini`)
-2. `swarph import <path>` — Phase 2.5 session import (Claude JSONL → swarph-native, with `--report-only` for honest pre-commit inspection)
+1. `swarph "prompt"` — Phase 2 one-shot mode (any of five providers)
+2. `swarph chat` — Phase 5 interactive REPL with multi-turn history + slash commands
+3. `swarph import <path>` — Phase 2.5 session import (Claude JSONL → swarph-native, with `--report-only` for honest pre-commit inspection)
 
-Subsequent phases extend the CLI surface (REPL, `--ask <peer>`, onboard/ratify, daemon, additional source formats).
+Subsequent phases extend the CLI surface (`--ask <peer>`, onboard/ratify, daemon, additional source formats).
+
+### `swarph chat`
+
+Interactive REPL against any of the five swarph-mesh adapters (`gemini` / `deepseek` / `claude` / `openai` / `grok`). Multi-turn conversation history accumulates in-memory; cumulative session cost + token totals tracked.
+
+```bash
+$ swarph chat --provider claude
+swarph chat — Phase 5 REPL
+provider=claude model=(adapter default) caller=cli.repl.ubuntu
+
+Type a message and press Enter to send. Slash commands:
+  /help  /clear  /system  /provider  /model  /history  /cost  /quit
+Ctrl-D to exit.
+
+> hello
+Hi! How can I help...
+# 8+12t  $0  0.34s
+
+> /provider gemini
+[switched to provider=gemini; model reset to adapter default; history cleared]
+
+> /cost
+[turns=1  in=8  out=12  cost=$0]
+
+> /quit
+[swarph-chat] bye.
+```
+
+**Slash commands:**
+- `/help` — print available commands
+- `/quit`, `/exit` (or Ctrl-D) — exit
+- `/clear`, `/reset` — clear history (keeps system prompt)
+- `/system [prompt]` — set or clear system prompt
+- `/provider <name>` — switch provider (resets history)
+- `/model <name>` — switch model
+- `/history` — print running message list
+- `/cost` — cumulative session cost + tokens
+
+**Out of scope until Phase 5.6** (`swarph daemon`): inbox drain coroutine, `/inbox` and `/reply` slash commands. Streaming output ships alongside the cross-adapter `stream()` work in v0.5+ of swarph-mesh.
 
 ### `swarph import`
 
@@ -83,13 +123,14 @@ Pong!
 
 | Phase | What lands |
 |---|---|
-| **0** (this) | Scaffold — entry-point + status banner |
-| **2** | One-shot mode: `swarph "hello" --provider gemini` |
+| **0** | Scaffold — entry-point + status banner |
+| **2** (v0.1.0) | One-shot mode: `swarph "hello" --provider gemini` |
+| **2.5** (v0.2.0) | `swarph import` — Claude JSONL → swarph-native session format |
+| **5** (v0.3.0 — this release) | **`swarph chat` interactive REPL** — multi-turn against any of five adapters + slash commands (`/help`, `/clear`, `/system`, `/provider`, `/model`, `/history`, `/cost`, `/quit`) |
 | **3** | `--ask <peer>` mesh-aware one-shot via MeshClient |
-| **5** | Interactive REPL — `/inbox`, `/reply`, `/dm`, `/watch` |
 | **5.5** | `swarph onboard <peer-name>` + `swarph ratify <peer-name>` (PLAN.md §15) |
-| **5.7** | `swarph daemon` foreground drain loop + `swarph chat` REPL with drain coroutine (PLAN.md §16) |
-| **6** | PyPI publish |
+| **5.6** | `swarph daemon` foreground drain loop + REPL drain coroutine + `/inbox`, `/reply` (PLAN.md §16) |
+| **6** | (already done) PyPI publish |
 
 ## Why split CLI from substrate
 

{swarph_cli-0.2.0 → swarph_cli-0.3.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.2.0"
-description = "The `swarph` binary — multi-LLM CLI with mesh-gateway integration. Phase 2 one-shot mode shipped (PLAN.md §13)."
+version = "0.3.0"
+description = "The `swarph` binary — multi-LLM CLI with mesh-gateway integration. v0.3.0 ships the Phase 5 `swarph chat` REPL on top of Phase 2 one-shot + Phase 2.5 import (PLAN.md §13)."
 readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.10"
@@ -29,7 +29,9 @@ classifiers = [
     "Topic :: Utilities",
 ]
 dependencies = [
-    "swarph-mesh>=0.1.0",
+    # Phase 5 REPL exercises all five adapters; bumped to 0.5.0 for
+    # OpenAI + Grok availability in /provider switch.
+    "swarph-mesh>=0.5.0",
     "swarph-shared>=0.2.0",
 ]
 

{swarph_cli-0.2.0 → swarph_cli-0.3.0}/src/swarph_cli/__init__.py

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

swarph_cli-0.3.0/src/swarph_cli/commands/chat.py

@@ -0,0 +1,348 @@
+"""``swarph chat`` — interactive REPL.
+
+Phase 5 per PLAN.md §13. Multi-turn conversation against any of the
+five swarph-mesh adapters (gemini / deepseek / claude / openai / grok).
+Stdlib-only — uses ``readline`` for line editing + in-process history,
+no third-party REPL framework.
+
+Slash commands (typed as the entire input):
+
+  /help                  — print this list
+  /quit | /exit          — exit (Ctrl-D also works)
+  /clear | /reset        — clear conversation history (keeps system prompt)
+  /system [prompt]       — show or set the system prompt; ``/system`` alone clears it
+  /provider <name>       — switch provider (resets the conversation)
+  /model <name>          — switch model
+  /history               — print the running message list
+  /cost                  — print cumulative session cost + token totals
+
+Out of scope per PLAN.md §13 (lands in 5.6):
+  /inbox /reply          — require the inbox-drain coroutine
+  background drain       — Phase 5.6 ``swarph daemon``
+
+Streaming output is not wired here — every swarph-mesh adapter raises
+``NotImplementedError`` on ``stream()`` as of v0.5.0; the REPL awaits
+the full response and prints in one block. Token-by-token streaming
+lands alongside the cross-adapter ``stream()`` work in v0.5+.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import Optional
+
+from swarph_cli.caller import default_caller
+
+
+_BANNER = """\
+swarph chat — Phase 5 REPL
+provider={provider} model={model} caller={caller}{system}
+
+Type a message and press Enter to send. Slash commands:
+  /help  /clear  /system  /provider  /model  /history  /cost  /quit
+Ctrl-D to exit.
+"""
+
+_HELP = """\
+Slash commands:
+  /help                 — show this list
+  /quit, /exit          — exit (Ctrl-D works too)
+  /clear, /reset        — clear conversation history (keeps system prompt)
+  /system [prompt]      — show or set system prompt; bare /system clears it
+  /provider <name>      — switch provider (clears history; rebinds adapter)
+  /model <name>         — switch model
+  /history              — print the running message list
+  /cost                 — print cumulative cost + token totals
+"""
+
+
+@dataclass
+class ReplState:
+    """In-memory REPL state. Lives for the duration of a single
+    ``swarph chat`` process."""
+
+    provider: str
+    model: Optional[str]
+    caller: str
+    system_prompt: Optional[str]
+    temperature: float = 0.7
+    max_tokens: Optional[int] = None
+    messages: list = field(default_factory=list)
+    total_input_tokens: int = 0
+    total_output_tokens: int = 0
+    total_cost_usd: float = 0.0
+    turn_count: int = 0
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="swarph chat",
+        description=(
+            "Interactive REPL against any swarph-mesh adapter. "
+            "Phase 5 per PLAN.md §13."
+        ),
+    )
+    p.add_argument(
+        "--provider",
+        default="gemini",
+        help='LLM provider (gemini / deepseek / claude / openai / grok).',
+    )
+    p.add_argument(
+        "--model",
+        default=None,
+        help="Provider-specific model id. Defaults to the adapter's default_model.",
+    )
+    p.add_argument(
+        "--caller",
+        default=None,
+        help='Caller-convention slug. Defaults to "cli.repl.<user>".',
+    )
+    p.add_argument(
+        "--system",
+        default=None,
+        help="System prompt prepended to every turn.",
+    )
+    p.add_argument(
+        "--temperature",
+        type=float,
+        default=0.7,
+    )
+    p.add_argument(
+        "--max-tokens",
+        type=int,
+        default=None,
+    )
+    return p
+
+
+def _default_repl_caller() -> str:
+    """``cli.repl.<user>`` — distinct from ``cli.oneshot.<user>`` so
+    attribution rows distinguish REPL turns from one-shot calls.
+
+    Falls back to the caller-convention default if env-derived user
+    extraction fails."""
+    user = os.environ.get("USER") or os.environ.get("LOGNAME")
+    if not user:
+        return default_caller()
+    user_slug = "".join(c if c.isalnum() else "_" for c in user.lower())
+    return f"cli.repl.{user_slug}"
+
+
+def _print(msg: str = "", *, file=None) -> None:
+    """Centralized print helper — tests monkeypatch this so they can
+    capture REPL output without poking sys.stdout."""
+    print(msg, file=file or sys.stdout, flush=True)
+
+
+def _read_line(prompt: str) -> str:
+    """Single-line input. Tests monkeypatch this to inject scripted
+    input. Production uses stdlib ``input()`` — readline is auto-loaded
+    by import-time on POSIX, giving line editing + history for free."""
+    try:
+        import readline  # noqa: F401 — side-effect-only on POSIX
+    except ImportError:
+        pass  # Windows / minimal builds; raw input still works
+    return input(prompt)
+
+
+def _format_attribution(
+    *, input_tokens: int, output_tokens: int, cost_usd: float, duration_s: float, cached: bool
+) -> str:
+    cost_str = f"${cost_usd:.4f}" if cost_usd > 0 else "$0"
+    line = (
+        f"# {input_tokens}+{output_tokens}t  "
+        f"{cost_str}  {duration_s:.2f}s"
+    )
+    if cached:
+        line += "  (cached)"
+    return line
+
+
+def _handle_slash(state: ReplState, line: str) -> str:
+    """Apply a slash command to ``state``. Return one of:
+
+    - ``"continue"`` — keep the REPL running
+    - ``"quit"``     — exit the REPL with code 0
+    - ``"unknown"``  — unrecognized command (caller prints + continues)
+    """
+    parts = line.split(maxsplit=1)
+    cmd = parts[0].lower()
+    arg = parts[1] if len(parts) > 1 else ""
+
+    if cmd in ("/quit", "/exit"):
+        return "quit"
+
+    if cmd == "/help":
+        _print(_HELP)
+        return "continue"
+
+    if cmd in ("/clear", "/reset"):
+        state.messages = []
+        _print("[cleared conversation history]")
+        return "continue"
+
+    if cmd == "/system":
+        if not arg:
+            if state.system_prompt:
+                _print(f"[system prompt cleared (was: {state.system_prompt!r})]")
+                state.system_prompt = None
+            else:
+                _print("[no system prompt set]")
+        else:
+            state.system_prompt = arg
+            _print(f"[system prompt set: {arg!r}]")
+        return "continue"
+
+    if cmd == "/provider":
+        if not arg:
+            _print(f"[current provider: {state.provider}]")
+            return "continue"
+        state.provider = arg
+        state.model = None  # adapter's default_model picks up
+        state.messages = []
+        _print(
+            f"[switched to provider={arg}; model reset to adapter default; "
+            f"history cleared]"
+        )
+        return "continue"
+
+    if cmd == "/model":
+        if not arg:
+            _print(f"[current model: {state.model or '(adapter default)'}]")
+            return "continue"
+        state.model = arg
+        _print(f"[switched to model={arg}]")
+        return "continue"
+
+    if cmd == "/history":
+        if not state.messages:
+            _print("[no messages yet]")
+            return "continue"
+        for i, m in enumerate(state.messages):
+            _print(f"  [{i}] {m.role}: {m.content[:200]}")
+        return "continue"
+
+    if cmd == "/cost":
+        cost_str = f"${state.total_cost_usd:.6f}" if state.total_cost_usd > 0 else "$0"
+        _print(
+            f"[turns={state.turn_count}  "
+            f"in={state.total_input_tokens}  out={state.total_output_tokens}  "
+            f"cost={cost_str}]"
+        )
+        return "continue"
+
+    return "unknown"
+
+
+async def _send_turn(state: ReplState, user_text: str) -> int:
+    """Send one user turn, append assistant reply on success. Returns
+    0 on success, non-zero on adapter error (REPL keeps running either
+    way; the return is for tests).
+
+    On adapter error the user turn is *not* appended to state.messages
+    so the user can retry the same input without doubling it up."""
+    # Local import — keeps the chat module importable in test contexts
+    # that don't have all five adapters installed.
+    from swarph_mesh import ChatMessage, SwarphCall
+
+    state.messages.append(ChatMessage(role="user", content=user_text))
+
+    try:
+        sc = SwarphCall(
+            provider=state.provider,
+            caller=state.caller,
+            model=state.model,
+        )
+        resp = await sc.chat(
+            messages=state.messages,
+            system_prompt=state.system_prompt,
+            temperature=state.temperature,
+            max_tokens=state.max_tokens,
+        )
+    except Exception as exc:
+        # Pop the failed user turn so retry doesn't compound it.
+        state.messages.pop()
+        _print(f"[error] {exc}", file=sys.stderr)
+        return 1
+
+    state.messages.append(ChatMessage(role="assistant", content=resp.text))
+    state.total_input_tokens += resp.input_tokens
+    state.total_output_tokens += resp.output_tokens
+    state.total_cost_usd += resp.cost_usd
+    state.turn_count += 1
+
+    _print(resp.text)
+    _print(
+        _format_attribution(
+            input_tokens=resp.input_tokens,
+            output_tokens=resp.output_tokens,
+            cost_usd=resp.cost_usd,
+            duration_s=resp.duration_s,
+            cached=resp.cached,
+        ),
+        file=sys.stderr,
+    )
+    return 0
+
+
+async def _repl_loop(state: ReplState) -> int:
+    """Main REPL loop. Returns process exit code."""
+    sys_line = f" system={state.system_prompt!r}" if state.system_prompt else ""
+    _print(
+        _BANNER.format(
+            provider=state.provider,
+            model=state.model or "(adapter default)",
+            caller=state.caller,
+            system=sys_line,
+        )
+    )
+
+    while True:
+        try:
+            line = _read_line("> ")
+        except EOFError:
+            _print()
+            _print("[swarph-chat] bye.")
+            return 0
+        except KeyboardInterrupt:
+            _print()
+            _print("[interrupted — type /quit to exit]")
+            continue
+
+        line = line.rstrip()
+        if not line:
+            continue
+
+        if line.startswith("/"):
+            result = _handle_slash(state, line)
+            if result == "quit":
+                _print("[swarph-chat] bye.")
+                return 0
+            if result == "unknown":
+                _print(f"[unknown command: {line.split()[0]!r} — try /help]")
+            continue
+
+        await _send_turn(state, line)
+
+
+def run_chat(argv: list[str]) -> int:
+    """Entry point invoked by ``swarph_cli.main`` verb dispatch.
+
+    Returns process exit code."""
+    args = _build_parser().parse_args(argv)
+    caller = args.caller or _default_repl_caller()
+
+    state = ReplState(
+        provider=args.provider,
+        model=args.model,
+        caller=caller,
+        system_prompt=args.system,
+        temperature=args.temperature,
+        max_tokens=args.max_tokens,
+    )
+
+    return asyncio.run(_repl_loop(state))

{swarph_cli-0.2.0 → swarph_cli-0.3.0}/src/swarph_cli/main.py

@@ -36,14 +36,16 @@ swarph v{version}
 
 Usage:
   swarph "your prompt here" [--provider gemini] [--model gemini-2.5-flash]
+  swarph chat [--provider deepseek] [--model deepseek-v4-flash] [--system PROMPT]
   swarph import <path-to-source-session> [--report-only] [--target-session NAME]
 
 Examples:
   swarph "explain Hawkes process briefly"
   swarph "list 5 tickers" --json
+  swarph chat --provider claude
   swarph import ~/.claude/projects/.../X.jsonl --report-only
 
-Status: Phase 2 one-shot + Phase 2.5 import ready. REPL (Phase 5),
+Status: Phase 2 one-shot + Phase 2.5 import + Phase 5 REPL ready.
 --ask <peer> (Phase 3), onboard/ratify (Phase 5.5), daemon (Phase 5.7)
 ship in subsequent releases.
 
@@ -55,7 +57,8 @@ Spec: https://github.com/darw007d/hedge-fund-mcp/blob/main/research/swarph_cli/P
 _VERB_HANDLERS: dict[str, str] = {
     # verb keyword: dotted-path to handler function (lazy-imported)
     "import": "swarph_cli.commands.import_session.run_import",
-    # Future: "chat", "daemon", "onboard", "ratify", "list-peers", etc.
+    "chat": "swarph_cli.commands.chat.run_chat",
+    # Future: "daemon", "onboard", "ratify", "list-peers", etc.
 }
 
 

{swarph_cli-0.2.0 → swarph_cli-0.3.0/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.2.0
-Summary: The `swarph` binary — multi-LLM CLI with mesh-gateway integration. Phase 2 one-shot mode shipped (PLAN.md §13).
+Version: 0.3.0
+Summary: The `swarph` binary — multi-LLM CLI with mesh-gateway integration. v0.3.0 ships the Phase 5 `swarph chat` REPL on top of Phase 2 one-shot + Phase 2.5 import (PLAN.md §13).
 Author: Pierre Samson, Claude Opus
 License: MIT
 Project-URL: Homepage, https://github.com/darw007d/swarph-cli
@@ -24,7 +24,7 @@ Classifier: Topic :: Utilities
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: swarph-mesh>=0.1.0
+Requires-Dist: swarph-mesh>=0.5.0
 Requires-Dist: swarph-shared>=0.2.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
@@ -49,12 +49,52 @@ This is one of three repos in the v0.3.x architecture:
 
 ## Status
 
-**v0.2.0 — Phase 2 one-shot + Phase 2.5 import.** Two verbs ship:
+**v0.3.0 — Phase 2 one-shot + Phase 2.5 import + Phase 5 REPL.** Three verbs ship:
 
-1. `swarph "prompt"` — Phase 2 one-shot mode (against `--provider gemini`)
-2. `swarph import <path>` — Phase 2.5 session import (Claude JSONL → swarph-native, with `--report-only` for honest pre-commit inspection)
+1. `swarph "prompt"` — Phase 2 one-shot mode (any of five providers)
+2. `swarph chat` — Phase 5 interactive REPL with multi-turn history + slash commands
+3. `swarph import <path>` — Phase 2.5 session import (Claude JSONL → swarph-native, with `--report-only` for honest pre-commit inspection)
 
-Subsequent phases extend the CLI surface (REPL, `--ask <peer>`, onboard/ratify, daemon, additional source formats).
+Subsequent phases extend the CLI surface (`--ask <peer>`, onboard/ratify, daemon, additional source formats).
+
+### `swarph chat`
+
+Interactive REPL against any of the five swarph-mesh adapters (`gemini` / `deepseek` / `claude` / `openai` / `grok`). Multi-turn conversation history accumulates in-memory; cumulative session cost + token totals tracked.
+
+```bash
+$ swarph chat --provider claude
+swarph chat — Phase 5 REPL
+provider=claude model=(adapter default) caller=cli.repl.ubuntu
+
+Type a message and press Enter to send. Slash commands:
+  /help  /clear  /system  /provider  /model  /history  /cost  /quit
+Ctrl-D to exit.
+
+> hello
+Hi! How can I help...
+# 8+12t  $0  0.34s
+
+> /provider gemini
+[switched to provider=gemini; model reset to adapter default; history cleared]
+
+> /cost
+[turns=1  in=8  out=12  cost=$0]
+
+> /quit
+[swarph-chat] bye.
+```
+
+**Slash commands:**
+- `/help` — print available commands
+- `/quit`, `/exit` (or Ctrl-D) — exit
+- `/clear`, `/reset` — clear history (keeps system prompt)
+- `/system [prompt]` — set or clear system prompt
+- `/provider <name>` — switch provider (resets history)
+- `/model <name>` — switch model
+- `/history` — print running message list
+- `/cost` — cumulative session cost + tokens
+
+**Out of scope until Phase 5.6** (`swarph daemon`): inbox drain coroutine, `/inbox` and `/reply` slash commands. Streaming output ships alongside the cross-adapter `stream()` work in v0.5+ of swarph-mesh.
 
 ### `swarph import`
 
@@ -115,13 +155,14 @@ Pong!
 
 | Phase | What lands |
 |---|---|
-| **0** (this) | Scaffold — entry-point + status banner |
-| **2** | One-shot mode: `swarph "hello" --provider gemini` |
+| **0** | Scaffold — entry-point + status banner |
+| **2** (v0.1.0) | One-shot mode: `swarph "hello" --provider gemini` |
+| **2.5** (v0.2.0) | `swarph import` — Claude JSONL → swarph-native session format |
+| **5** (v0.3.0 — this release) | **`swarph chat` interactive REPL** — multi-turn against any of five adapters + slash commands (`/help`, `/clear`, `/system`, `/provider`, `/model`, `/history`, `/cost`, `/quit`) |
 | **3** | `--ask <peer>` mesh-aware one-shot via MeshClient |
-| **5** | Interactive REPL — `/inbox`, `/reply`, `/dm`, `/watch` |
 | **5.5** | `swarph onboard <peer-name>` + `swarph ratify <peer-name>` (PLAN.md §15) |
-| **5.7** | `swarph daemon` foreground drain loop + `swarph chat` REPL with drain coroutine (PLAN.md §16) |
-| **6** | PyPI publish |
+| **5.6** | `swarph daemon` foreground drain loop + REPL drain coroutine + `/inbox`, `/reply` (PLAN.md §16) |
+| **6** | (already done) PyPI publish |
 
 ## Why split CLI from substrate
 

{swarph_cli-0.2.0 → swarph_cli-0.3.0}/src/swarph_cli.egg-info/SOURCES.txt

@@ -11,10 +11,13 @@ src/swarph_cli.egg-info/entry_points.txt
 src/swarph_cli.egg-info/requires.txt
 src/swarph_cli.egg-info/top_level.txt
 src/swarph_cli/commands/__init__.py
+src/swarph_cli/commands/chat.py
 src/swarph_cli/commands/import_session.py
 src/swarph_cli/parsers/__init__.py
 src/swarph_cli/parsers/claude.py
+tests/test_chat_command.py
 tests/test_claude_parser.py
 tests/test_import_command.py
 tests/test_main.py
+tests/test_smoke_chat.py
 tests/test_smoke_one_shot.py

{swarph_cli-0.2.0 → swarph_cli-0.3.0}/src/swarph_cli.egg-info/requires.txt

@@ -1,4 +1,4 @@
-swarph-mesh>=0.1.0
+swarph-mesh>=0.5.0
 swarph-shared>=0.2.0
 
 [dev]

swarph_cli-0.3.0/tests/test_chat_command.py

@@ -0,0 +1,444 @@
+"""Tests for ``swarph chat`` REPL — offline only, mocked stdin + adapter.
+
+Live smoke (one round-trip via REPL) lives in ``test_smoke_chat.py``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from unittest.mock import patch
+
+import pytest
+
+from swarph_cli.commands import chat as chat_cmd
+from swarph_cli.commands.chat import (
+    ReplState,
+    _default_repl_caller,
+    _format_attribution,
+    _handle_slash,
+)
+
+
+# ---------------------------------------------------------------------------
+# Caller default
+# ---------------------------------------------------------------------------
+
+
+def test_default_repl_caller_uses_user_env(monkeypatch):
+    monkeypatch.setenv("USER", "pierre")
+    assert _default_repl_caller() == "cli.repl.pierre"
+
+
+def test_default_repl_caller_slugs_non_alnum(monkeypatch):
+    monkeypatch.setenv("USER", "Some.User-1")
+    monkeypatch.delenv("LOGNAME", raising=False)
+    assert _default_repl_caller() == "cli.repl.some_user_1"
+
+
+def test_default_repl_caller_falls_back_when_user_unset(monkeypatch):
+    monkeypatch.delenv("USER", raising=False)
+    monkeypatch.delenv("LOGNAME", raising=False)
+    out = _default_repl_caller()
+    # caller must satisfy the dotted-lowercase convention even on
+    # fallback — swarph_shared.validate_caller is strict.
+    assert out
+    assert out.islower()
+    assert " " not in out
+
+
+# ---------------------------------------------------------------------------
+# Attribution footer
+# ---------------------------------------------------------------------------
+
+
+def test_format_attribution_zero_cost_renders_dollar_zero():
+    s = _format_attribution(
+        input_tokens=10, output_tokens=5, cost_usd=0.0, duration_s=1.23, cached=False
+    )
+    assert "$0" in s
+    assert "$0.0000" not in s  # the >0 branch shouldn't fire
+
+
+def test_format_attribution_nonzero_cost_renders_4dp():
+    s = _format_attribution(
+        input_tokens=100,
+        output_tokens=50,
+        cost_usd=0.0123,
+        duration_s=2.0,
+        cached=False,
+    )
+    assert "$0.0123" in s
+
+
+def test_format_attribution_marks_cached():
+    s = _format_attribution(
+        input_tokens=10, output_tokens=5, cost_usd=0.001, duration_s=0.5, cached=True
+    )
+    assert "(cached)" in s
+
+
+# ---------------------------------------------------------------------------
+# Slash commands — pure state mutation
+# ---------------------------------------------------------------------------
+
+
+def _state(provider="gemini", model=None, system=None) -> ReplState:
+    return ReplState(
+        provider=provider,
+        model=model,
+        caller="cli.repl.test",
+        system_prompt=system,
+    )
+
+
+def test_slash_quit_returns_quit():
+    s = _state()
+    assert _handle_slash(s, "/quit") == "quit"
+
+
+def test_slash_exit_alias_returns_quit():
+    s = _state()
+    assert _handle_slash(s, "/exit") == "quit"
+
+
+def test_slash_help_returns_continue():
+    s = _state()
+    assert _handle_slash(s, "/help") == "continue"
+
+
+def test_slash_clear_resets_messages():
+    s = _state()
+    s.messages = ["m1", "m2", "m3"]
+    assert _handle_slash(s, "/clear") == "continue"
+    assert s.messages == []
+
+
+def test_slash_reset_alias_clears_messages():
+    s = _state()
+    s.messages = ["m1"]
+    assert _handle_slash(s, "/reset") == "continue"
+    assert s.messages == []
+
+
+def test_slash_clear_keeps_system_prompt():
+    s = _state(system="be terse")
+    s.messages = ["m1"]
+    _handle_slash(s, "/clear")
+    assert s.system_prompt == "be terse"
+
+
+def test_slash_system_with_arg_sets_prompt():
+    s = _state()
+    _handle_slash(s, "/system you are an assistant")
+    assert s.system_prompt == "you are an assistant"
+
+
+def test_slash_system_bare_clears_prompt():
+    s = _state(system="be terse")
+    _handle_slash(s, "/system")
+    assert s.system_prompt is None
+
+
+def test_slash_provider_switch_resets_history():
+    s = _state(provider="gemini")
+    s.messages = ["m1", "m2"]
+    s.model = "gemini-2.5-flash"
+    _handle_slash(s, "/provider claude")
+    assert s.provider == "claude"
+    assert s.model is None  # picks up adapter default
+    assert s.messages == []
+
+
+def test_slash_provider_bare_shows_current(capsys):
+    s = _state(provider="grok")
+    _handle_slash(s, "/provider")
+    captured = capsys.readouterr()
+    assert "grok" in captured.out
+
+
+def test_slash_model_sets_model():
+    s = _state()
+    _handle_slash(s, "/model deepseek-v4-pro")
+    assert s.model == "deepseek-v4-pro"
+
+
+def test_slash_history_with_no_messages(capsys):
+    s = _state()
+    _handle_slash(s, "/history")
+    captured = capsys.readouterr()
+    assert "no messages" in captured.out
+
+
+def test_slash_cost_prints_running_totals(capsys):
+    s = _state()
+    s.turn_count = 3
+    s.total_input_tokens = 150
+    s.total_output_tokens = 75
+    s.total_cost_usd = 0.0042
+    _handle_slash(s, "/cost")
+    out = capsys.readouterr().out
+    assert "turns=3" in out
+    assert "in=150" in out
+    assert "out=75" in out
+    assert "$0.004200" in out
+
+
+def test_slash_cost_zero_renders_dollar_zero(capsys):
+    s = _state()
+    _handle_slash(s, "/cost")
+    out = capsys.readouterr().out
+    assert "cost=$0]" in out
+
+
+def test_unknown_slash_returns_unknown():
+    s = _state()
+    assert _handle_slash(s, "/banana split") == "unknown"
+
+
+# ---------------------------------------------------------------------------
+# _send_turn — adapter wiring with mocked SwarphCall
+# ---------------------------------------------------------------------------
+
+
+def _mock_response(*, text="ok", in_tok=10, out_tok=5, cost=0.001, dur=1.0, cached=False):
+    """Build a minimal LLMResponse-compatible shape."""
+    from swarph_mesh.types import LLMResponse
+
+    return LLMResponse(
+        text=text,
+        input_tokens=in_tok,
+        output_tokens=out_tok,
+        cost_usd=cost,
+        duration_s=dur,
+        cached=cached,
+    )
+
+
+class _FakeSwarphCall:
+    """Drop-in for SwarphCall in chat tests. Captures the args it was
+    called with so tests can assert on them."""
+
+    captured: list = []
+    response: object = None
+    raise_exc: object = None
+
+    def __init__(self, *, provider, caller, model=None):
+        self.provider = provider
+        self.caller = caller
+        self.model = model
+
+    async def chat(self, **kwargs):
+        # Snapshot the messages list at call time — the REPL mutates
+        # the same list after the call returns (appends assistant turn),
+        # so a reference-only capture would show post-call state.
+        snapshot = dict(kwargs)
+        if "messages" in snapshot:
+            snapshot["messages"] = list(snapshot["messages"])
+        type(self).captured.append({"kwargs": snapshot, "model": self.model})
+        if type(self).raise_exc is not None:
+            raise type(self).raise_exc
+        return type(self).response
+
+
+@pytest.fixture
+def fake_call(monkeypatch):
+    """Patch swarph_mesh.SwarphCall in the chat module's namespace."""
+    _FakeSwarphCall.captured = []
+    _FakeSwarphCall.response = _mock_response()
+    _FakeSwarphCall.raise_exc = None
+
+    # The chat module imports SwarphCall locally inside _send_turn, so
+    # we patch swarph_mesh.SwarphCall directly.
+    import swarph_mesh
+
+    monkeypatch.setattr(swarph_mesh, "SwarphCall", _FakeSwarphCall)
+    return _FakeSwarphCall
+
+
+def test_send_turn_appends_assistant_reply(fake_call):
+    s = _state()
+    fake_call.response = _mock_response(text="hi there")
+    asyncio.run(chat_cmd._send_turn(s, "hello"))
+    assert len(s.messages) == 2
+    assert s.messages[0].role == "user"
+    assert s.messages[0].content == "hello"
+    assert s.messages[1].role == "assistant"
+    assert s.messages[1].content == "hi there"
+
+
+def test_send_turn_accumulates_cost_and_tokens(fake_call):
+    s = _state()
+    fake_call.response = _mock_response(in_tok=20, out_tok=10, cost=0.005)
+    asyncio.run(chat_cmd._send_turn(s, "q1"))
+    asyncio.run(chat_cmd._send_turn(s, "q2"))
+    assert s.turn_count == 2
+    assert s.total_input_tokens == 40
+    assert s.total_output_tokens == 20
+    assert s.total_cost_usd == pytest.approx(0.010)
+
+
+def test_send_turn_passes_system_prompt_through(fake_call):
+    s = _state(system="be terse")
+    asyncio.run(chat_cmd._send_turn(s, "q"))
+    assert fake_call.captured[0]["kwargs"]["system_prompt"] == "be terse"
+
+
+def test_send_turn_passes_temperature_and_max_tokens(fake_call):
+    s = _state()
+    s.temperature = 0.1
+    s.max_tokens = 256
+    asyncio.run(chat_cmd._send_turn(s, "q"))
+    kw = fake_call.captured[0]["kwargs"]
+    assert kw["temperature"] == 0.1
+    assert kw["max_tokens"] == 256
+
+
+def test_send_turn_threads_messages_for_multiturn_history(fake_call):
+    """Second turn must include the first user+assistant turn so the
+    adapter sees the full context."""
+    s = _state()
+    fake_call.response = _mock_response(text="a1")
+    asyncio.run(chat_cmd._send_turn(s, "q1"))
+    fake_call.response = _mock_response(text="a2")
+    asyncio.run(chat_cmd._send_turn(s, "q2"))
+
+    second_call_messages = fake_call.captured[1]["kwargs"]["messages"]
+    assert len(second_call_messages) == 3  # q1, a1, q2 (the new turn)
+    assert second_call_messages[0].content == "q1"
+    assert second_call_messages[1].content == "a1"
+    assert second_call_messages[2].content == "q2"
+
+
+def test_send_turn_pops_user_turn_on_adapter_error(fake_call, capsys):
+    """Adapter error: user can retry without doubling the input."""
+    s = _state()
+    fake_call.raise_exc = RuntimeError("provider exploded")
+    rc = asyncio.run(chat_cmd._send_turn(s, "q"))
+    assert rc == 1
+    assert s.messages == []  # popped
+    assert s.turn_count == 0
+    err = capsys.readouterr().err
+    assert "[error]" in err
+    assert "provider exploded" in err
+
+
+# ---------------------------------------------------------------------------
+# REPL loop — script stdin via _read_line monkeypatch
+# ---------------------------------------------------------------------------
+
+
+def _scripted_input(lines: list[str]):
+    """Build a _read_line replacement that returns each line in order,
+    then raises EOFError to terminate the loop cleanly."""
+    it = iter(lines)
+
+    def fake(prompt):
+        try:
+            return next(it)
+        except StopIteration:
+            raise EOFError()
+
+    return fake
+
+
+def test_repl_loop_exits_on_eof(monkeypatch, fake_call, capsys):
+    monkeypatch.setattr(chat_cmd, "_read_line", _scripted_input([]))
+    s = _state()
+    rc = asyncio.run(chat_cmd._repl_loop(s))
+    assert rc == 0
+    out = capsys.readouterr().out
+    assert "swarph chat" in out  # banner printed
+    assert "bye" in out
+
+
+def test_repl_loop_exits_on_quit(monkeypatch, fake_call):
+    monkeypatch.setattr(chat_cmd, "_read_line", _scripted_input(["/quit"]))
+    s = _state()
+    rc = asyncio.run(chat_cmd._repl_loop(s))
+    assert rc == 0
+
+
+def test_repl_loop_round_trips_one_message(monkeypatch, fake_call):
+    fake_call.response = _mock_response(text="response_text")
+    monkeypatch.setattr(chat_cmd, "_read_line", _scripted_input(["hello", "/quit"]))
+    s = _state()
+    asyncio.run(chat_cmd._repl_loop(s))
+    assert s.turn_count == 1
+    assert s.messages[0].content == "hello"
+    assert s.messages[1].content == "response_text"
+
+
+def test_repl_loop_skips_empty_lines(monkeypatch, fake_call):
+    """Empty/whitespace input shouldn't trigger an LLM call."""
+    monkeypatch.setattr(
+        chat_cmd, "_read_line", _scripted_input(["", "   ", "/quit"])
+    )
+    s = _state()
+    asyncio.run(chat_cmd._repl_loop(s))
+    assert s.turn_count == 0
+    assert fake_call.captured == []
+
+
+def test_repl_loop_handles_keyboard_interrupt(monkeypatch, fake_call, capsys):
+    """Ctrl-C mid-line should print an interrupt notice and continue,
+    not abort the REPL."""
+    state_iter = iter([KeyboardInterrupt(), "/quit"])
+
+    def fake_read(prompt):
+        v = next(state_iter)
+        if isinstance(v, BaseException):
+            raise v
+        return v
+
+    monkeypatch.setattr(chat_cmd, "_read_line", fake_read)
+    s = _state()
+    rc = asyncio.run(chat_cmd._repl_loop(s))
+    assert rc == 0
+    out = capsys.readouterr().out
+    assert "interrupted" in out
+
+
+def test_repl_loop_unknown_slash_message(monkeypatch, fake_call, capsys):
+    monkeypatch.setattr(
+        chat_cmd, "_read_line", _scripted_input(["/banana", "/quit"])
+    )
+    s = _state()
+    asyncio.run(chat_cmd._repl_loop(s))
+    out = capsys.readouterr().out
+    assert "unknown command" in out
+
+
+def test_repl_loop_provider_switch_clears_history(monkeypatch, fake_call):
+    fake_call.response = _mock_response(text="r1")
+    monkeypatch.setattr(
+        chat_cmd,
+        "_read_line",
+        _scripted_input(["q1", "/provider claude", "/quit"]),
+    )
+    s = _state(provider="gemini")
+    asyncio.run(chat_cmd._repl_loop(s))
+    assert s.provider == "claude"
+    assert s.messages == []  # cleared on switch
+
+
+# ---------------------------------------------------------------------------
+# Verb dispatch — main.py routes "chat" to run_chat
+# ---------------------------------------------------------------------------
+
+
+def test_main_dispatches_chat_verb(monkeypatch):
+    """``swarph chat ...`` should land in run_chat with rest of argv."""
+    from swarph_cli import main as main_mod
+
+    captured = {}
+
+    def fake_run_chat(argv):
+        captured["argv"] = argv
+        return 0
+
+    monkeypatch.setattr(
+        "swarph_cli.commands.chat.run_chat", fake_run_chat
+    )
+    rc = main_mod.main(["chat", "--provider", "claude"])
+    assert rc == 0
+    assert captured["argv"] == ["--provider", "claude"]

swarph_cli-0.3.0/tests/test_smoke_chat.py

@@ -0,0 +1,61 @@
+"""Live smoke for ``swarph chat`` REPL — Phase 5 falsifiability gate per
+PLAN.md §13 (manual verification proxy).
+
+Single round-trip: scripted stdin sends one user turn + /quit, REPL
+calls the real adapter, asserts response written + state correct.
+
+Skipped unless GEMINI_API_KEY is set — gemini-flash is the cheapest tier
+across all five adapters and the established Phase 1 falsifiability
+target.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+
+import pytest
+
+from swarph_cli.commands import chat as chat_cmd
+from swarph_cli.commands.chat import ReplState
+
+
+pytestmark = pytest.mark.skipif(
+    not os.environ.get("GEMINI_API_KEY"),
+    reason="GEMINI_API_KEY not set — Phase 5 live smoke skipped",
+)
+
+
+def test_phase_5_repl_falsifiability_gate(monkeypatch):
+    """One scripted user turn through the real REPL → real adapter →
+    real response. State should reflect: 1 turn, history populated,
+    cumulative cost > 0."""
+    inputs = iter(["say PONG and nothing else", "/quit"])
+
+    def fake_read(prompt):
+        try:
+            return next(inputs)
+        except StopIteration:
+            raise EOFError()
+
+    monkeypatch.setattr(chat_cmd, "_read_line", fake_read)
+
+    state = ReplState(
+        provider="gemini",
+        model=None,  # adapter default (flash)
+        caller="cli.smoke.phase_5_gate",
+        system_prompt=None,
+        temperature=0.0,
+        max_tokens=8,
+    )
+    rc = asyncio.run(chat_cmd._repl_loop(state))
+
+    assert rc == 0
+    assert state.turn_count == 1
+    assert len(state.messages) == 2
+    assert state.messages[0].role == "user"
+    assert state.messages[1].role == "assistant"
+    assert state.messages[1].content
+    assert state.total_input_tokens > 0
+    assert state.total_output_tokens > 0
+    assert state.total_cost_usd >= 0.0  # Flex tier could rebate near 0