simplicio-cli 0.8.0__tar.gz → 0.9.1__tar.gz

{simplicio_cli-0.8.0/simplicio_cli.egg-info → simplicio_cli-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-cli
-Version: 0.8.0
+Version: 0.9.1
 Summary: Portable task-to-code pipeline that works with any LLM. Turn a one-line task into a verified code change — diff + test + verify loop. +55 pts on a 156-check benchmark, 21% faster, ~same tokens.
 Author-email: Wesley Simplicio <wesleybob4@gmail.com>
 License: MIT
@@ -30,7 +30,7 @@ Requires-Dist: sentence-transformers>=5.6.0
 Requires-Dist: numpy>=2.5.0
 Requires-Dist: anthropic>=0.112.0
 Requires-Dist: openai>=2.44.0
-Requires-Dist: simplicio-mapper>=0.11.0
+Requires-Dist: simplicio-mapper>=0.13.0
 Requires-Dist: simplicio-prompt>=1.14.1
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: orjson>=3.11.9

{simplicio_cli-0.8.0 → simplicio_cli-0.9.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simplicio-cli"
-version = "0.8.0"
+version = "0.9.1"
 description = "Portable task-to-code pipeline that works with any LLM. Turn a one-line task into a verified code change — diff + test + verify loop. +55 pts on a 156-check benchmark, 21% faster, ~same tokens."
 readme = "README.md"
 license = { text = "MIT" }
@@ -44,7 +44,7 @@ dependencies = [
   "numpy>=2.5.0",
   "anthropic>=0.112.0",
   "openai>=2.44.0",
-  "simplicio-mapper>=0.11.0",
+  "simplicio-mapper>=0.13.0",
   "simplicio-prompt>=1.14.1",
   "httpx>=0.28.1",
   "orjson>=3.11.9",

simplicio_cli-0.9.1/simplicio/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.9.1"

{simplicio_cli-0.8.0 → simplicio_cli-0.9.1}/simplicio/cli.py

@@ -97,11 +97,6 @@ def _try_route_via_simplicio(
 
 
 def _dispatch_nested(argv: list[str]) -> int | None:
-    if argv and argv[0] == "claims":
-        maybe_autoinstall("claims")
-        from .commands.claims import main as claims_main
-
-        return claims_main(argv[1:])
     if argv and argv[0] == "gate":
         clean_args, native, python = _parse_rust_flags(argv[1:])
         result = _try_route_via_simplicio(
@@ -552,10 +547,56 @@ def _write_sprint_state(
     path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")
 
 
+def _status_claims_gate(payload: dict[str, object]) -> dict[str, object]:
+    """Return a low-risk claim contract for ``status --json`` consumers.
+
+    A persisted sprint state can prove that this adapter recorded a fresh,
+    passing local execution for the tracked sprint flow. It still cannot prove
+    repo-wide green on its own, so downstream consumers must not escalate that
+    broader claim from a single status payload.
+    """
+
+    failed_features = payload.get("failed_features")
+    failed_dod_gates = payload.get("failed_dod_gates")
+    state = payload.get("state") or ("complete" if payload.get("complete") else "in-progress")
+    has_fresh_passing_state = (
+        bool(payload.get("complete"))
+        and state == "complete"
+        and not failed_features
+        and not failed_dod_gates
+    )
+    if not has_fresh_passing_state:
+        return {
+            "allow_fresh_verification_claim": False,
+            "allow_repo_green_claim": False,
+            "proof_scope": "none",
+            "reason": "fresh passing verification evidence is not available",
+        }
+    return {
+        "allow_fresh_verification_claim": True,
+        "allow_repo_green_claim": False,
+        "proof_scope": "sprint_state",
+        "reason": (
+            "last passing evidence came from the stored sprint state; "
+            "it does not prove repo-wide green"
+        ),
+    }
+
+
 def _run_status_command(a: argparse.Namespace) -> int:
-    state_path = Path(a.root) / ".simplicio" / "sprint_state.json"
+    from .mapper import artifact_status
+
+    root = Path(a.root).resolve()
+    state_path = root / ".simplicio" / "sprint_state.json"
     if not state_path.is_file():
-        payload = {"state": "none", "path": str(state_path)}
+        payload = {
+            "schema": "simplicio.dev-cli.status/v1",
+            "root": str(root),
+            "state": "none",
+            "path": str(state_path),
+            "artifacts": artifact_status(root),
+        }
+        payload["claims_gate"] = _status_claims_gate(payload)
         if a.json:
             print(json.dumps(payload, sort_keys=True))
         else:
@@ -566,8 +607,15 @@ def _run_status_command(a: argparse.Namespace) -> int:
     except json.JSONDecodeError as exc:
         print(f"{CLI_PROG} status: invalid state file: {exc}", file=sys.stderr)
         return 2
+    json_payload = {
+        "schema": "simplicio.dev-cli.status/v1",
+        "root": str(root),
+        **payload,
+        "artifacts": artifact_status(root),
+    }
+    json_payload["claims_gate"] = _status_claims_gate(json_payload)
     if a.json:
-        print(json.dumps(payload, sort_keys=True))
+        print(json.dumps(json_payload, sort_keys=True))
         return 0
     completed = payload.get("completed_features", 0)
     total = payload.get("total_features", 0)
@@ -709,6 +757,60 @@ def _run_runtime_command(a: argparse.Namespace) -> int:
     return 2
 
 
+def _run_claims_command(a: argparse.Namespace) -> int:
+    from .commands.claims import main as claims_main
+
+    claims_argv = [a.claims_cmd]
+    if a.claims_cmd in {"check", "tag"}:
+        claims_argv.extend(a.statement)
+    elif a.claims_cmd == "report":
+        if a.path:
+            claims_argv += ["--path", a.path]
+        if a.json_file:
+            claims_argv += ["--json", a.json_file]
+        claims_argv.extend(a.claims)
+    return claims_main(claims_argv)
+
+
+def _run_file_command(a: argparse.Namespace) -> int:
+    from .commands.file_read import run as file_read_run
+
+    if a.file_cmd == "read":
+        return file_read_run(a)
+    print(f"{CLI_PROG} file: unsupported command", file=sys.stderr)
+    return 2
+
+
+def _run_test_command(a: argparse.Namespace) -> int:
+    from .commands.test_run import run as test_run_run
+
+    if a.test_cmd == "run":
+        extra_args = a.extra_args
+        if extra_args and extra_args[0] == "--":
+            extra_args = extra_args[1:]
+        # `--cmd` is parsed into `test_program` to avoid colliding with the
+        # top-level subparser's `dest="cmd"`; translate to the attribute
+        # name `commands/test_run.py` expects.
+        a.cmd = a.test_program
+        return test_run_run(a, extra_args)
+    print(f"{CLI_PROG} test: unsupported command", file=sys.stderr)
+    return 2
+
+
+def _run_inspect_command(a: argparse.Namespace) -> int:
+    from .mapper import inspect_target
+
+    payload = {
+        "schema": "simplicio.dev-cli.inspect/v1",
+        **inspect_target(a.root, a.target, goal=a.goal),
+    }
+    if a.json:
+        print(json.dumps(payload, sort_keys=True))
+    else:
+        print(payload["context"])
+    return 0
+
+
 def _run_run_command(a: argparse.Namespace) -> int:
     from .intent import AUTO_CONFIDENCE_THRESHOLD, classify_goal
 
@@ -804,6 +906,23 @@ def main(argv=None):
     p_status.add_argument("--root", default=".")
     p_status.add_argument("--json", action="store_true")
 
+    p_claims = sub.add_parser("claims", help="claims-gate checks and report generation")
+    claims_sub = p_claims.add_subparsers(dest="claims_cmd", required=True)
+    p_claims_check = claims_sub.add_parser("check", help="verify a claim against the 8 rules")
+    p_claims_check.add_argument("statement", nargs="+")
+    p_claims_tag = claims_sub.add_parser("tag", help="suggest MEASURED|CANON|UNVERIFIED")
+    p_claims_tag.add_argument("statement", nargs="+")
+    p_claims_report = claims_sub.add_parser("report", help="generate/load a claims report")
+    p_claims_report.add_argument("claims", nargs="*")
+    p_claims_report.add_argument("--path")
+    p_claims_report.add_argument("--json", dest="json_file")
+
+    p_inspect = sub.add_parser("inspect", help="inspect a target with mapper-backed context")
+    p_inspect.add_argument("target")
+    p_inspect.add_argument("--root", default=".")
+    p_inspect.add_argument("--goal", default="")
+    p_inspect.add_argument("--json", action="store_true")
+
     p_doctor = sub.add_parser(
         "doctor",
         help="check local llama.cpp readiness and dependency freshness",
@@ -847,6 +966,36 @@ def main(argv=None):
         help="use the Python mechanical-edit fallback instead of delegating to simplicio edit",
     )
 
+    p_file = sub.add_parser("file", help="read raw file contents")
+    file_sub = p_file.add_subparsers(dest="file_cmd", required=True)
+    p_file_read = file_sub.add_parser(
+        "read", help="print a file's contents, optionally sliced by line range"
+    )
+    p_file_read.add_argument("path")
+    p_file_read.add_argument("--json", action="store_true")
+    p_file_read.add_argument("--start", type=int, default=None, help="1-indexed inclusive start line")
+    p_file_read.add_argument("--end", type=int, default=None, help="1-indexed inclusive end line")
+    p_file_read.add_argument("--max-bytes", type=int, default=None, dest="max_bytes")
+    p_file_read.add_argument("--repo", default=".")
+
+    p_test = sub.add_parser("test", help="run a test command and report results")
+    test_sub = p_test.add_subparsers(dest="test_cmd", required=True)
+    p_test_run = test_sub.add_parser("run", help="run a test command (default: pytest)")
+    p_test_run.add_argument("--cmd", dest="test_program", default="pytest")
+    p_test_run.add_argument("--json", action="store_true")
+    p_test_run.add_argument("--repo", default=".")
+    p_test_run.add_argument(
+        "--timeout",
+        type=float,
+        default=120.0,
+        help="seconds to wait for the test command before giving up (default: 120)",
+    )
+    p_test_run.add_argument(
+        "extra_args",
+        nargs=argparse.REMAINDER,
+        help="extra args passed through to --cmd after a literal --",
+    )
+
     p_token = sub.add_parser("token", help="token-efficient execution primitives")
     token_sub = p_token.add_subparsers(dest="token_cmd", required=True)
     p_log = token_sub.add_parser("log-summary")
@@ -989,6 +1138,10 @@ def main(argv=None):
         return detect_main(detect_argv)
     elif a.cmd == "status":
         return _run_status_command(a)
+    elif a.cmd == "claims":
+        return _run_claims_command(a)
+    elif a.cmd == "inspect":
+        return _run_inspect_command(a)
     elif a.cmd == "doctor":
         from .doctor import main as doctor_main
 
@@ -1026,6 +1179,10 @@ def main(argv=None):
         return _run_mechanical_edit_command(a)
     elif a.cmd == "edit":
         return _run_edit_command(a)
+    elif a.cmd == "file":
+        return _run_file_command(a)
+    elif a.cmd == "test":
+        return _run_test_command(a)
     elif a.cmd == "token":
         return _run_token_command(a)
     elif a.cmd == "score-skill":

simplicio_cli-0.9.1/simplicio/commands/file_read.py

@@ -0,0 +1,155 @@
+"""``file read`` — read raw file contents with optional line-range slicing.
+
+Delegates to the native Rust ``simplicio file read`` binary when available
+(via :mod:`simplicio.runtime_bridge`), falling back to a pure-Python
+implementation otherwise. Mirrors the Rust CLI contract exactly so either
+implementation is interchangeable from the caller's point of view::
+
+    simplicio-dev-cli file read <path> [--json] [--start N] [--end N]
+                                 [--max-bytes N] [--repo <path>]
+
+JSON output shape (schema ``simplicio.file-read/v1``)::
+
+    {"schema": "simplicio.file-read/v1", "path": "...", "bytes": N,
+     "lines": N, "truncated": bool, "content": "..."}
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+from ..runtime_bridge import discover_simplicio
+
+SCHEMA = "simplicio.file-read/v1"
+DEFAULT_MAX_BYTES = 2 * 1024 * 1024  # 2 MiB
+# A file read should be near-instant; this is just a safety net against a
+# hung/misbehaving Rust binary, not a tunable (unlike test run's --timeout).
+RUNTIME_DELEGATION_TIMEOUT_S = 30.0
+
+
+def _build_runtime_args(a: argparse.Namespace) -> list[str]:
+    cmd = ["file", "read", a.path, "--json"]
+    if a.start is not None:
+        cmd += ["--start", str(a.start)]
+    if a.end is not None:
+        cmd += ["--end", str(a.end)]
+    if a.max_bytes is not None:
+        cmd += ["--max-bytes", str(a.max_bytes)]
+    if a.repo:
+        cmd += ["--repo", a.repo]
+    return cmd
+
+
+def _run_via_runtime(a: argparse.Namespace) -> int | None:
+    """Attempt delegation to the Rust ``simplicio`` binary.
+
+    Returns the exit code on success, or ``None`` so the caller falls back
+    to the Python implementation (binary missing, or the call errored).
+    """
+    binary = discover_simplicio()
+    if binary is None:
+        return None
+    cmd = [binary, *_build_runtime_args(a)]
+    try:
+        completed = subprocess.run(
+            cmd, capture_output=True, text=True, timeout=RUNTIME_DELEGATION_TIMEOUT_S
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+
+    # Only trust the Rust binary's result if it actually produced the
+    # expected JSON envelope — an unimplemented/erroring subcommand prints
+    # a plain-text message and exits non-zero, which is indistinguishable
+    # from a legitimate error by exit code alone.
+    try:
+        payload = json.loads(completed.stdout)
+    except (json.JSONDecodeError, ValueError):
+        return None
+    if payload.get("schema") != SCHEMA:
+        return None
+
+    if a.json:
+        print(completed.stdout, end="")
+    else:
+        print(payload.get("content", ""), end="")
+    if completed.stderr:
+        print(completed.stderr, end="", file=sys.stderr)
+    return completed.returncode
+
+
+def _read_fallback(a: argparse.Namespace) -> tuple[dict | None, str | None]:
+    """Read the file per Python fallback rules.
+
+    Returns ``(payload, error_message)`` — exactly one is non-``None``.
+    """
+    repo_root = Path(a.repo or ".").resolve()
+    target = (repo_root / a.path).resolve() if not Path(a.path).is_absolute() else Path(a.path)
+
+    if not target.exists():
+        return None, f"file not found: {a.path}"
+    if target.is_dir():
+        return None, f"path is a directory, not a file: {a.path}"
+
+    max_bytes = a.max_bytes if a.max_bytes is not None else DEFAULT_MAX_BYTES
+    try:
+        raw = target.read_bytes()
+    except OSError as exc:
+        return None, f"cannot read {a.path}: {exc}"
+
+    truncated = len(raw) > max_bytes
+    if truncated:
+        raw = raw[:max_bytes]
+
+    # Decode strictly: this CLI is a direct, local, single-user invocation
+    # (not the MCP-exposed path) — a non-UTF8 file is a real error the user
+    # should see rather than a silently mangled read.
+    try:
+        text = raw.decode("utf-8")
+    except UnicodeDecodeError as exc:
+        return None, f"file is not valid UTF-8: {a.path} ({exc})"
+
+    lines = text.splitlines(keepends=True)
+    if a.start is not None or a.end is not None:
+        start = max(a.start or 1, 1)
+        end = a.end if a.end is not None else len(lines)
+        # 1-indexed inclusive slice
+        text = "".join(lines[start - 1:end])
+        line_count = len(text.splitlines())
+    else:
+        line_count = len(lines)
+
+    payload = {
+        "schema": SCHEMA,
+        "path": a.path,
+        "bytes": len(text.encode("utf-8")),
+        "lines": line_count,
+        "truncated": truncated,
+        "content": text,
+    }
+    return payload, None
+
+
+def _run_fallback(a: argparse.Namespace) -> int:
+    payload, error = _read_fallback(a)
+    if error is not None:
+        print(f"simplicio-dev-cli file read: {error}", file=sys.stderr)
+        return 2
+
+    assert payload is not None
+    if a.json:
+        print(json.dumps(payload, sort_keys=True))
+    else:
+        print(payload["content"], end="")
+    return 0
+
+
+def run(a: argparse.Namespace) -> int:
+    """Entry point wired from ``cli.py`` for ``simplicio-dev-cli file read``."""
+    result = _run_via_runtime(a)
+    if result is not None:
+        return result
+    return _run_fallback(a)

simplicio_cli-0.9.1/simplicio/commands/test_run.py

@@ -0,0 +1,236 @@
+"""``test run`` — run a test command and report structured pass/fail results.
+
+Delegates to the native Rust ``simplicio test run`` binary when available
+(via :mod:`simplicio.runtime_bridge`), falling back to a pure-Python
+implementation otherwise. Mirrors the Rust CLI contract exactly::
+
+    simplicio-dev-cli test run [--cmd <program>] [--json] [--repo <path>]
+                                [-- <extra-args...>]
+
+``--cmd`` is passed as ``argv[0]`` directly — never through a shell — with
+anything after a literal ``--`` forwarded as additional argv elements.
+
+JSON output shape (schema ``simplicio.test-run/v1``)::
+
+    {"schema": "simplicio.test-run/v1", "cmd": "pytest", "args": [...],
+     "exit_code": N, "passed": N|null, "failed": N|null, "errors": N|null,
+     "duration_s": F|null, "summary": "...", "output_tail": "...",
+     "output_truncated": bool}
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+from ..runtime_bridge import discover_simplicio
+
+SCHEMA = "simplicio.test-run/v1"
+DEFAULT_CMD = "pytest"
+OUTPUT_TAIL_CHARS = 4000
+DEFAULT_TIMEOUT_S = 120.0
+# Extra budget on top of the user's --timeout when delegating to the Rust
+# binary, so the binary's own internal timeout gets a chance to fire and
+# return a clean JSON payload before Python gives up on the subprocess call.
+RUNTIME_DELEGATION_TIMEOUT_SLACK_S = 15.0
+
+# Matches pytest's final summary line, e.g.:
+#   "3 passed, 1 failed in 0.42s"
+#   "1 passed, 1 error in 0.02s"
+#   "24 deselected in 0.02s"
+_PYTEST_COUNT_RE = re.compile(r"(\d+)\s+(passed|failed|error(?:s)?)\b")
+_PYTEST_DURATION_RE = re.compile(r"\bin\s+([\d.]+)s\b")
+_PYTEST_SUMMARY_LINE_RE = re.compile(
+    r"^=+ .* (?:passed|failed|error|deselected|no tests ran).* =+\s*$",
+    re.MULTILINE,
+)
+
+
+def _build_runtime_args(a: argparse.Namespace, extra_args: list[str]) -> list[str]:
+    cmd = ["test", "run", "--cmd", a.cmd, "--json"]
+    if a.repo:
+        cmd += ["--repo", a.repo]
+    if extra_args:
+        cmd += ["--", *extra_args]
+    return cmd
+
+
+def _run_via_runtime(a: argparse.Namespace, extra_args: list[str]) -> int | None:
+    """Attempt delegation to the Rust ``simplicio`` binary.
+
+    Returns the exit code on success, or ``None`` so the caller falls back
+    to the Python implementation (binary missing, or the call errored in a
+    way that suggests the subcommand isn't implemented there yet).
+    """
+    binary = discover_simplicio()
+    if binary is None:
+        return None
+    cmd = [binary, *_build_runtime_args(a, extra_args)]
+    try:
+        completed = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=a.timeout + RUNTIME_DELEGATION_TIMEOUT_SLACK_S,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+
+    try:
+        payload = json.loads(completed.stdout)
+    except (json.JSONDecodeError, ValueError):
+        return None
+    if payload.get("schema") != SCHEMA:
+        return None
+
+    if a.json:
+        print(completed.stdout, end="")
+    else:
+        _print_human(payload)
+    if completed.stderr:
+        print(completed.stderr, end="", file=sys.stderr)
+    return completed.returncode
+
+
+def _parse_pytest_summary(output: str) -> tuple[int | None, int | None, int | None, float | None, str | None]:
+    """Parse pytest's summary line for pass/fail/error counts and duration.
+
+    Returns ``(passed, failed, errors, duration_s, summary_line)``. Any
+    field that cannot be determined is ``None``.
+    """
+    lines = output.splitlines()
+    summary_line = None
+    for line in reversed(lines):
+        if _PYTEST_COUNT_RE.search(line) or "no tests ran" in line.lower():
+            summary_line = line.strip().strip("=").strip()
+            break
+
+    if summary_line is None:
+        return None, None, None, None, None
+
+    counts = {"passed": 0, "failed": 0, "error": 0, "errors": 0}
+    for match in _PYTEST_COUNT_RE.finditer(summary_line):
+        count, label = match.groups()
+        counts[label] = int(count)
+
+    duration_match = _PYTEST_DURATION_RE.search(summary_line)
+    duration = float(duration_match.group(1)) if duration_match else None
+
+    passed = counts["passed"]
+    failed = counts["failed"]
+    errors = counts["error"] + counts["errors"]
+
+    return passed, failed, errors, duration, summary_line
+
+
+def _run_fallback(a: argparse.Namespace, extra_args: list[str]) -> int:
+    repo_root = Path(a.repo or ".").resolve()
+    argv = [a.cmd, *extra_args]
+
+    try:
+        completed = subprocess.run(
+            argv,
+            capture_output=True,
+            text=True,
+            cwd=repo_root,
+            timeout=a.timeout,
+        )
+    except FileNotFoundError:
+        print(
+            f"simplicio-dev-cli test run: command not found: {a.cmd!r}",
+            file=sys.stderr,
+        )
+        return 1
+    except subprocess.TimeoutExpired as exc:
+        combined = (exc.stdout or "") + (exc.stderr or "")
+        output_truncated = len(combined) > OUTPUT_TAIL_CHARS
+        output_tail = combined[-OUTPUT_TAIL_CHARS:] if output_truncated else combined
+        payload = {
+            "schema": SCHEMA,
+            "cmd": a.cmd,
+            "args": extra_args,
+            "exit_code": None,
+            "passed": None,
+            "failed": None,
+            "errors": None,
+            "duration_s": None,
+            "summary": f"{a.cmd}: timed out after {a.timeout}s",
+            "output_tail": output_tail,
+            "output_truncated": output_truncated,
+        }
+        if a.json:
+            print(json.dumps(payload, sort_keys=True))
+        else:
+            _print_human(payload)
+        return 124  # shell convention for "command timed out"
+    except OSError as exc:
+        print(f"simplicio-dev-cli test run: failed to launch {a.cmd!r}: {exc}", file=sys.stderr)
+        return 1
+
+    combined_output = completed.stdout + completed.stderr
+
+    passed = failed = errors = None
+    duration_s = None
+    summary = None
+    is_pytest = a.cmd == "pytest" or "pytest" in a.cmd or "= test session starts =" in combined_output
+    if is_pytest:
+        passed, failed, errors, duration_s, summary = _parse_pytest_summary(combined_output)
+
+    if summary is None:
+        summary = (
+            f"{a.cmd} exited {completed.returncode}"
+            if completed.returncode != 0
+            else f"{a.cmd} exited 0"
+        )
+
+    output_truncated = len(combined_output) > OUTPUT_TAIL_CHARS
+    output_tail = combined_output[-OUTPUT_TAIL_CHARS:] if output_truncated else combined_output
+
+    payload = {
+        "schema": SCHEMA,
+        "cmd": a.cmd,
+        "args": extra_args,
+        "exit_code": completed.returncode,
+        "passed": passed,
+        "failed": failed,
+        "errors": errors,
+        "duration_s": duration_s,
+        "summary": summary,
+        "output_tail": output_tail,
+        "output_truncated": output_truncated,
+    }
+
+    if a.json:
+        print(json.dumps(payload, sort_keys=True))
+    else:
+        _print_human(payload)
+
+    return completed.returncode
+
+
+def _print_human(payload: dict) -> None:
+    print(f"{payload['cmd']}: {payload['summary']}")
+    if payload.get("passed") is not None or payload.get("failed") is not None:
+        print(
+            f"  passed={payload.get('passed')} "
+            f"failed={payload.get('failed')} "
+            f"errors={payload.get('errors')}"
+        )
+    print(f"  exit_code={payload['exit_code']}")
+    if payload.get("output_tail"):
+        print("--- output tail ---")
+        print(payload["output_tail"], end="" if payload["output_tail"].endswith("\n") else "\n")
+        if payload.get("output_truncated"):
+            print("(output truncated)")
+
+
+def run(a: argparse.Namespace, extra_args: list[str]) -> int:
+    """Entry point wired from ``cli.py`` for ``simplicio-dev-cli test run``."""
+    result = _run_via_runtime(a, extra_args)
+    if result is not None:
+        return result
+    return _run_fallback(a, extra_args)