run-harness 0.1.0__py3-none-any.whl

run_harness/__init__.py

@@ -0,0 +1 @@
+"""run-harness: one CLI for coding-agent harnesses."""

run_harness/__main__.py

@@ -0,0 +1,3 @@
+from run_harness.cli import main
+
+raise SystemExit(main())

run_harness/adapters/__init__.py

@@ -0,0 +1,16 @@
+"""Harness adapters and their registry."""
+
+from __future__ import annotations
+
+from run_harness.adapters.base import Adapter
+from run_harness.adapters.claude import ClaudeAdapter
+from run_harness.adapters.codex import CodexAdapter
+from run_harness.adapters.opencode import OpenCodeAdapter
+from run_harness.adapters.pi import PiAdapter
+
+ADAPTERS: dict[str, Adapter] = {
+    "claude": ClaudeAdapter(),
+    "codex": CodexAdapter(),
+    "opencode": OpenCodeAdapter(),
+    "pi": PiAdapter(),
+}

run_harness/adapters/base.py

@@ -0,0 +1,156 @@
+"""Adapter interface shared by every harness (spec section 7)."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from abc import ABC, abstractmethod
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any, Protocol, TextIO
+
+from run_harness.request import HelperNotFound, RunRequest
+
+
+@dataclass(frozen=True)
+class FinalMessage:
+    """The stream produced a final message (possibly empty)."""
+
+    text: str
+
+
+@dataclass(frozen=True)
+class StreamFailure:
+    """The stream reported an error or had no final message. The run exits 1."""
+
+    error_text: str
+
+
+Outcome = FinalMessage | StreamFailure
+
+
+class StreamHandler(Protocol):
+    def feed(self, line: str) -> None:
+        """Called once per stdout line as it arrives, line ending kept."""
+
+    def finish(self) -> Outcome:
+        """Called once after stdout closes."""
+
+
+def parse_json_line(line: str) -> dict[str, Any] | None:
+    """Parse one JSONL line into an object. None for non-JSON, truncated or non-object lines."""
+    try:
+        value = json.loads(line)
+    except ValueError:
+        return None
+    return value if isinstance(value, dict) else None
+
+
+def ensure_newline(text: str) -> str:
+    """`text` with a trailing newline added only when it is missing."""
+    return text if text.endswith("\n") else text + "\n"
+
+
+def resolve_executable(name: str, env: Mapping[str, str]) -> str:
+    """Resolve `name` on the env's PATH. Raises HelperNotFound when it isn't there."""
+    resolved = shutil.which(name, path=env.get("PATH"))
+    if resolved is None:
+        raise HelperNotFound(f"{name}: not found on PATH")
+    return resolved
+
+
+class ProgressWriter:
+    """Writes the progress the JSON-mode handlers render to stderr.
+
+    Text that stderr can't encode (surrogates from undecodable bytes) is written with
+    backslash escapes instead of raising.
+    """
+
+    def __init__(self, stderr: TextIO) -> None:
+        self._stderr = stderr
+
+    def _emit(self, text: str) -> None:
+        self._stderr.write(text.encode("utf-8", "backslashreplace").decode("utf-8"))
+        self._stderr.flush()
+
+    def text(self, text: str) -> None:
+        """Assistant text. Nothing when empty."""
+        if text:
+            self._emit(ensure_newline(text))
+
+    def tool(self, name: object) -> None:
+        """A tool call. Nothing when the name is missing or empty."""
+        if isinstance(name, str) and name:
+            self._emit(f"→ tool: {name}\n")
+
+    def raw(self, line: str) -> None:
+        """A non-JSON line, verbatim. Nothing when it is empty or whitespace-only."""
+        if line.strip():
+            self._emit(ensure_newline(line))
+
+
+def run_check(argv: list[str], env: Mapping[str, str], cwd: str) -> tuple[int, str]:
+    """Run a pre-launch check helper with the run's env and cwd.
+
+    Returns (exit code, stdout). A negative exit code means a signal. Raises HelperNotFound
+    when argv[0] is not on the env's PATH. The helper's stdin is closed and its stderr dropped.
+    """
+    resolved = resolve_executable(argv[0], env)
+    result = subprocess.run(
+        argv,
+        executable=resolved,
+        cwd=cwd,
+        env=dict(env),
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.DEVNULL,
+        check=False,
+    )
+    return result.returncode, result.stdout.decode("utf-8", errors="replace")
+
+
+class Adapter(ABC):
+    """One harness. Subclasses implement `command` and `new_stream_handler`.
+
+    Facts: `precheck` may return a mapping of facts it detected (e.g. Pi's major version). The
+    runner then calls `build` again with them, and `build` hands them to `command`, which every
+    adapter accepts (and most ignore).
+    """
+
+    @abstractmethod
+    def command(
+        self, request: RunRequest, environ: Mapping[str, str], facts: Mapping[str, Any]
+    ) -> tuple[list[str], Mapping[str, str]]:
+        """Return the full argv (starting with the executable name) and env overrides.
+
+        Pure. The overrides are applied on top of `environ`; PWD is handled by `build`.
+        `facts` is what `precheck` returned (empty when it found nothing).
+        """
+
+    def build(
+        self,
+        request: RunRequest,
+        environ: Mapping[str, str],
+        facts: Mapping[str, Any] | None = None,
+    ) -> tuple[list[str], dict[str, str]]:
+        """Return (argv, child env). Pure; PWD is always set to the request's cwd.
+
+        `facts` is what `precheck` returned for this request, if anything.
+        """
+        argv, overrides = self.command(request, environ, facts or {})
+        env = dict(environ)
+        env.update(overrides)
+        env["PWD"] = request.cwd
+        return argv, env
+
+    def precheck(self, request: RunRequest, env: Mapping[str, str]) -> Mapping[str, Any]:
+        """Pre-launch checks. Raise UsageError (exit 2) or HelperNotFound (exit 127).
+
+        Returns facts for `command`; the default checks nothing and returns none.
+        """
+        return {}
+
+    @abstractmethod
+    def new_stream_handler(self, stderr: TextIO) -> StreamHandler:
+        """A fresh handler for one run. JSON-mode handlers render progress to `stderr`."""

run_harness/adapters/claude.py

@@ -0,0 +1,101 @@
+"""Claude Code adapter (spec sections 4.1, 5, 6)."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TextIO
+
+from run_harness.adapters.base import (
+    Adapter,
+    FinalMessage,
+    Outcome,
+    ProgressWriter,
+    StreamFailure,
+    StreamHandler,
+    parse_json_line,
+)
+from run_harness.request import RunRequest
+
+
+class ClaudeStreamHandler:
+    """Render progress from stream-json events and keep the last `result` event."""
+
+    def __init__(self, stderr: TextIO) -> None:
+        self._progress = ProgressWriter(stderr)
+        self._result: dict[str, Any] | None = None
+
+    def feed(self, line: str) -> None:
+        event = parse_json_line(line)
+        if event is None:
+            # Not JSON (or a truncated line): forward it raw.
+            self._progress.raw(line)
+            return
+        kind = event.get("type")
+        if kind == "result":
+            self._result = event
+        elif kind == "assistant":
+            self._render_assistant(event)
+
+    def _render_assistant(self, event: dict[str, Any]) -> None:
+        message = event.get("message")
+        content = message.get("content") if isinstance(message, dict) else None
+        if not isinstance(content, list):
+            return
+        for block in content:
+            if not isinstance(block, dict):
+                continue
+            if block.get("type") == "text":
+                text = block.get("text")
+                if isinstance(text, str):
+                    self._progress.text(text)
+            elif block.get("type") == "tool_use":
+                self._progress.tool(block.get("name"))
+
+    def finish(self) -> Outcome:
+        result = self._result
+        if result is None:
+            return StreamFailure("claude: stream ended without a result event")
+        text = result.get("result")
+        if result.get("is_error") is True:
+            if isinstance(text, str) and text:
+                return StreamFailure(text)
+            return StreamFailure(self._describe_error(result))
+        if isinstance(text, str):
+            return FinalMessage(text)
+        return StreamFailure(self._describe_error(result))
+
+    @staticmethod
+    def _describe_error(result: dict[str, Any]) -> str:
+        errors = result.get("errors")
+        if isinstance(errors, list) and errors:
+            return "; ".join(str(e) for e in errors)
+        subtype = result.get("subtype")
+        return str(subtype) if subtype else "claude: result event has no result text"
+
+
+class ClaudeAdapter(Adapter):
+    def command(
+        self, request: RunRequest, environ: Mapping[str, str], facts: Mapping[str, Any]
+    ) -> tuple[list[str], Mapping[str, str]]:
+        # No positional prompt: it goes in on stdin. In read-only mode the variadic --tools is
+        # followed by a non-variadic flag, so later arguments can't be swallowed by it.
+        argv = ["claude", "-p", "--output-format", "stream-json", "--verbose"]
+        if request.autonomous:
+            argv += ["--dangerously-skip-permissions"]
+        else:
+            argv += [
+                "--tools",
+                "Read,Grep,Glob",
+                "--permission-mode",
+                "dontAsk",
+                "--strict-mcp-config",
+            ]
+        if request.model is not None:
+            argv += ["--model", request.model]
+        if request.effort is not None:
+            argv += ["--effort", request.effort]
+        argv += request.passthrough
+        return argv, {}
+
+    def new_stream_handler(self, stderr: TextIO) -> StreamHandler:
+        return ClaudeStreamHandler(stderr)

run_harness/adapters/codex.py

@@ -0,0 +1,43 @@
+"""Codex adapter (spec section 4.2)."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TextIO
+
+from run_harness.adapters.base import Adapter, FinalMessage, Outcome, StreamHandler
+from run_harness.request import RunRequest
+
+
+class CodexStreamHandler:
+    """Codex's stdout, when piped, is the final message. Buffer it verbatim."""
+
+    def __init__(self) -> None:
+        self._parts: list[str] = []
+
+    def feed(self, line: str) -> None:
+        self._parts.append(line)
+
+    def finish(self) -> Outcome:
+        return FinalMessage("".join(self._parts))
+
+
+class CodexAdapter(Adapter):
+    def command(
+        self, request: RunRequest, environ: Mapping[str, str], facts: Mapping[str, Any]
+    ) -> tuple[list[str], Mapping[str, str]]:
+        # No positional prompt: Codex reads it from stdin to EOF.
+        argv = ["codex", "exec", "--skip-git-repo-check", "--color", "never"]
+        if request.autonomous:
+            argv += ["--dangerously-bypass-approvals-and-sandbox"]
+        else:
+            argv += ["-s", "read-only"]
+        if request.model is not None:
+            argv += ["-m", request.model]
+        if request.effort is not None:
+            argv += ["-c", f"model_reasoning_effort={request.effort}"]
+        argv += request.passthrough
+        return argv, {}
+
+    def new_stream_handler(self, stderr: TextIO) -> StreamHandler:
+        return CodexStreamHandler()

run_harness/adapters/opencode.py

@@ -0,0 +1,243 @@
+"""OpenCode adapter (spec section 4.4)."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from typing import Any, TextIO
+
+from run_harness.adapters.base import (
+    Adapter,
+    FinalMessage,
+    Outcome,
+    ProgressWriter,
+    StreamFailure,
+    StreamHandler,
+    parse_json_line,
+    run_check,
+)
+from run_harness.request import RunRequest, UsageError
+
+CONFIG_VAR = "OPENCODE_CONFIG_CONTENT"
+READONLY_AGENT = "run-harness-readonly"
+READONLY_AGENT_CONFIG: dict[str, Any] = {
+    "mode": "primary",
+    "description": "run-harness read-only",
+    "permission": {
+        "*": "deny",
+        "read": "allow",
+        "glob": "allow",
+        "grep": "allow",
+        "list": "allow",
+        "lsp": "allow",
+    },
+}
+
+
+def merged_config(caller_value: str | None) -> str:
+    """The caller's config with only `agent.run-harness-readonly` added or replaced."""
+    if caller_value is None:
+        config: Any = {}
+    else:
+        try:
+            config = json.loads(caller_value)
+        except ValueError as exc:
+            raise UsageError(f"{CONFIG_VAR} is not valid JSON: {exc}") from exc
+    if not isinstance(config, dict):
+        raise UsageError(f"{CONFIG_VAR} must be a JSON object")
+    agents = config.get("agent", {})
+    if not isinstance(agents, dict):
+        raise UsageError(f'{CONFIG_VAR}: "agent" must be a JSON object')
+    config["agent"] = {**agents, READONLY_AGENT: READONLY_AGENT_CONFIG}
+    return json.dumps(config, separators=(",", ":"))
+
+
+def _expected_permissions() -> list[dict[str, str]]:
+    permission = READONLY_AGENT_CONFIG["permission"]
+    return [
+        {"action": action, "resource": "*", "effect": effect}
+        for action, effect in permission.items()
+    ]
+
+
+def check_readonly_agent(output: str) -> None:
+    """Confirm `opencode api GET /api/config` shows the injected agent with its deny rules.
+
+    The output is a JSON list of config documents in merge order. The last document that
+    defines `run-harness-readonly` wins, so its permissions must be exactly the injected ones
+    (`* deny` first, then the read-only allows). Raises ValueError otherwise.
+    """
+    try:
+        documents = json.loads(output)
+    except ValueError as exc:
+        raise ValueError(f"unparseable config output: {exc}") from exc
+    if not isinstance(documents, list):
+        raise ValueError("config output is not a JSON list")
+    definition: Any = None
+    for document in documents:
+        info = document.get("info") if isinstance(document, dict) else None
+        agents = info.get("agents") if isinstance(info, dict) else None
+        if isinstance(agents, dict) and READONLY_AGENT in agents:
+            definition = agents[READONLY_AGENT]
+    if definition is None:
+        raise ValueError(f"agent {READONLY_AGENT!r} is not in the effective config")
+    permissions = definition.get("permissions") if isinstance(definition, dict) else None
+    if permissions != _expected_permissions():
+        raise ValueError(f"agent {READONLY_AGENT!r} does not have the injected permissions")
+
+
+def parse_model_variants(output: str) -> dict[str, list[str]]:
+    """Parse `opencode api GET /api/model` into {"provider/model": [variant ids]}.
+
+    Raises ValueError when the output is not the expected `{"data": [model, ...]}` shape.
+    """
+    try:
+        document = json.loads(output)
+    except ValueError as exc:
+        raise ValueError(f"unparseable model list: {exc}") from exc
+    data = document.get("data") if isinstance(document, dict) else None
+    if not isinstance(data, list):
+        raise ValueError('model list has no "data" list')
+    models: dict[str, list[str]] = {}
+    for model in data:
+        if not isinstance(model, dict):
+            raise ValueError("model entry is not a JSON object")
+        provider, model_id, variants = (
+            model.get("providerID"),
+            model.get("modelID"),
+            model.get("variants", []),
+        )
+        if not isinstance(provider, str) or not isinstance(model_id, str):
+            raise ValueError("model entry has no providerID/modelID")
+        if not isinstance(variants, list):
+            raise ValueError(f"variants of {provider}/{model_id} is not a list")
+        models[f"{provider}/{model_id}"] = [
+            v["id"] for v in variants if isinstance(v, dict) and isinstance(v.get("id"), str)
+        ]
+    return models
+
+
+def _error_message(error: Any) -> str:
+    if isinstance(error, dict):
+        if isinstance(error.get("message"), str) and error["message"]:
+            return error["message"]
+        data = error.get("data")
+        if isinstance(data, dict) and isinstance(data.get("message"), str) and data["message"]:
+            return data["message"]
+        if isinstance(error.get("name"), str) and error["name"]:
+            return error["name"]
+    elif isinstance(error, str) and error:
+        return error
+    return "opencode reported an error"
+
+
+class OpenCodeStreamHandler:
+    """Renders progress to stderr and extracts the last assistant message's text."""
+
+    def __init__(self, stderr: TextIO) -> None:
+        self._progress = ProgressWriter(stderr)
+        self._text_parts: list[tuple[Any, str]] = []
+        self._saw_step_finish = False
+        self._final_message_id: Any = None
+        self._errors: list[str] = []
+
+    def feed(self, line: str) -> None:
+        event = parse_json_line(line)
+        if event is None:
+            self._progress.raw(line)
+            return
+        kind = event.get("type")
+        part = event.get("part")
+        if not isinstance(part, dict):
+            part = {}
+        if kind == "text" and isinstance(part.get("text"), str):
+            self._text_parts.append((part.get("messageID"), part["text"]))
+            self._final_message_id = part.get("messageID")
+            self._progress.text(part["text"])
+        elif kind == "tool_use":
+            self._progress.tool(part.get("tool"))
+        elif kind == "step_finish":
+            self._saw_step_finish = True
+            self._final_message_id = part.get("messageID")
+        elif kind == "error":
+            self._errors.append(_error_message(event.get("error")))
+
+    def finish(self) -> Outcome:
+        if self._errors:
+            return StreamFailure("\n".join(self._errors))
+        if not self._text_parts and not self._saw_step_finish:
+            return StreamFailure("opencode finished without a final message")
+        # The last text or step_finish event names the final message: 2.x ends with the final
+        # text (no step_finish after it), 1.x ends with the step_finish of that message.
+        final_id = self._final_message_id
+        return FinalMessage(
+            "".join(text for message_id, text in self._text_parts if message_id == final_id)
+        )
+
+
+class OpenCodeAdapter(Adapter):
+    def command(
+        self, request: RunRequest, environ: Mapping[str, str], facts: Mapping[str, Any]
+    ) -> tuple[list[str], Mapping[str, str]]:
+        # No positional prompt: `opencode run` reads it from stdin to EOF. --standalone runs a
+        # private server that sees this child's env (the shared background service would not).
+        argv = ["opencode", "run", "--standalone", "--format", "json"]
+        overrides: dict[str, str] = {}
+        if request.autonomous:
+            argv += ["--auto"]
+        else:
+            argv += ["--agent", READONLY_AGENT]
+            overrides[CONFIG_VAR] = merged_config(environ.get(CONFIG_VAR))
+        if request.model is not None:
+            # 2.x has no --variant: the effort level is the `#variant` suffix of the model.
+            suffix = f"#{request.effort}" if request.effort is not None else ""
+            argv += ["-m", f"{request.model}{suffix}"]
+        argv += request.passthrough
+        return argv, overrides
+
+    def precheck(self, request: RunRequest, env: Mapping[str, str]) -> Mapping[str, Any]:
+        if not request.autonomous:
+            self._check_readonly_agent(request, env)
+        if request.effort is not None:
+            self._check_effort(request, env)
+        return {}
+
+    def _check_readonly_agent(self, request: RunRequest, env: Mapping[str, str]) -> None:
+        argv = ["opencode", "api", "--standalone", "GET", "/api/config"]
+        code, output = run_check(argv, env, request.cwd)
+        if code != 0:
+            raise UsageError(
+                f"read-only mode cannot be guaranteed: `{' '.join(argv)}` exited {code}"
+            )
+        try:
+            check_readonly_agent(output)
+        except ValueError as exc:
+            raise UsageError(f"read-only mode cannot be guaranteed: {exc}") from exc
+
+    def _check_effort(self, request: RunRequest, env: Mapping[str, str]) -> None:
+        model, effort = request.model, request.effort
+        if model is None:
+            raise UsageError("--effort requires --model for opencode")
+        if "#" in model:
+            raise UsageError("--effort cannot be combined with a #variant in --model")
+        argv = ["opencode", "api", "--standalone", "GET", "/api/model"]
+        code, output = run_check(argv, env, request.cwd)
+        if code != 0:
+            raise UsageError(f"cannot validate --effort: `{' '.join(argv)}` exited {code}")
+        try:
+            models = parse_model_variants(output)
+        except ValueError as exc:
+            raise UsageError(f"cannot validate --effort: unexpected model list: {exc}") from exc
+        variants = models.get(model)
+        if variants is None:
+            raise UsageError(f"cannot validate --effort: model {model!r} is not listed")
+        if not variants:
+            raise UsageError(f"model {model!r} has no variants, so --effort is not supported")
+        if effort not in variants:
+            raise UsageError(
+                f"--effort {effort!r} is not a variant of {model!r} "
+                f"(available: {', '.join(sorted(variants))})"
+            )
+
+    def new_stream_handler(self, stderr: TextIO) -> StreamHandler:
+        return OpenCodeStreamHandler(stderr)

run_harness/adapters/pi.py

@@ -0,0 +1,113 @@
+"""Pi adapter (spec sections 4.3, 5 and 6)."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Mapping
+from typing import Any, TextIO
+
+from run_harness.adapters.base import (
+    Adapter,
+    FinalMessage,
+    Outcome,
+    ProgressWriter,
+    StreamFailure,
+    StreamHandler,
+    parse_json_line,
+    run_check,
+)
+from run_harness.request import RunRequest, UsageError
+
+_VERSION = re.compile(r"\s*v?(\d+)\.(\d+)\.(\d+)")
+MAJOR_FACT = "pi_major"
+
+
+def parse_major_version(output: str) -> int | None:
+    """Major version from the leading MAJOR.MINOR.PATCH of `pi --version`, else None."""
+    match = _VERSION.match(output)
+    return int(match.group(1)) if match else None
+
+
+def _text_of(message: dict[str, Any]) -> str:
+    content = message.get("content")
+    if not isinstance(content, list):
+        return ""
+    return "".join(
+        block["text"]
+        for block in content
+        if isinstance(block, dict)
+        and block.get("type") == "text"
+        and isinstance(block.get("text"), str)
+    )
+
+
+class PiStreamHandler:
+    """Extracts the last assistant `message_end` and renders progress to stderr."""
+
+    def __init__(self, stderr: TextIO) -> None:
+        self._progress = ProgressWriter(stderr)
+        self._last_assistant_message: dict[str, Any] | None = None
+
+    def feed(self, line: str) -> None:
+        event = parse_json_line(line)
+        if event is None:  # not JSON, or a truncated last line: show it raw
+            self._progress.raw(line)
+            return
+        kind = event.get("type")
+        if kind == "message_end":
+            message = event.get("message")
+            if isinstance(message, dict) and message.get("role") == "assistant":
+                self._last_assistant_message = message
+                self._progress.text(_text_of(message))
+        elif kind == "tool_execution_start":
+            self._progress.tool(event.get("toolName"))
+
+    def finish(self) -> Outcome:
+        message = self._last_assistant_message
+        if message is None:
+            return StreamFailure("pi: no final assistant message in the event stream")
+        stop = message.get("stopReason")
+        if stop in ("error", "aborted"):
+            error = message.get("errorMessage")
+            return StreamFailure(error if isinstance(error, str) and error else f"pi: {stop}")
+        return FinalMessage(_text_of(message))
+
+
+class PiAdapter(Adapter):
+    def command(
+        self,
+        request: RunRequest,
+        environ: Mapping[str, str],
+        facts: Mapping[str, Any],
+    ) -> tuple[list[str], Mapping[str, str]]:
+        # No positional prompt and no -p: in JSON mode Pi reads the prompt from stdin.
+        argv = ["pi", "--mode", "json"]
+        if not request.autonomous:
+            argv += ["--tools", "read,grep,find,ls"]
+            if facts.get(MAJOR_FACT, 0) >= 1:
+                argv += ["--no-mcp"]
+        if request.model is not None:
+            argv += ["--model", request.model]
+        if request.effort is not None:
+            argv += ["--thinking", request.effort]
+        argv += request.passthrough
+        return argv, {}
+
+    def precheck(self, request: RunRequest, env: Mapping[str, str]) -> Mapping[str, Any]:
+        if request.autonomous:
+            return {}
+        code, stdout = run_check(["pi", "--version"], env, request.cwd)
+        if code != 0:
+            raise UsageError(
+                f"`pi --version` exited {code}; cannot tell whether read-only can be enforced"
+            )
+        major = parse_major_version(stdout)
+        if major is None:
+            raise UsageError(
+                f"could not parse `pi --version` output {stdout.strip()!r}; "
+                "cannot tell whether read-only can be enforced"
+            )
+        return {MAJOR_FACT: major}
+
+    def new_stream_handler(self, stderr: TextIO) -> StreamHandler:
+        return PiStreamHandler(stderr)

run_harness/cli.py

@@ -0,0 +1,182 @@
+"""Command-line surface: argv -> validated RunRequest (spec section 2)."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from collections.abc import Sequence
+from importlib import metadata
+from typing import BinaryIO, NoReturn
+
+from run_harness.request import HARNESSES, MAX_PROMPT_BYTES, RunRequest, UsageError
+
+EFFORT_LEVELS = ("low", "medium", "high", "max")
+
+PROMPT_ADVICE = (
+    "A prompt that begins with '-' cannot be given as the PROMPT argument, and neither "
+    "should any untrusted text. Send those through -f/--prompt-file or through stdin "
+    "(PROMPT = '-')."
+)
+
+
+class _Parser(argparse.ArgumentParser):
+    """Argument parser whose usage errors raise UsageError instead of exiting."""
+
+    def error(self, message: str) -> NoReturn:
+        raise UsageError(f"{self.prog}: {message}")
+
+
+def _version() -> str:
+    try:
+        return metadata.version("run-harness")
+    except metadata.PackageNotFoundError:  # pragma: no cover
+        return "unknown"
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = _Parser(
+        prog="run-harness",
+        allow_abbrev=False,
+        description="Run one coding-agent harness non-interactively and print its final message.",
+        epilog=PROMPT_ADVICE,
+    )
+    parser.add_argument("--version", action="version", version=f"run-harness {_version()}")
+    subparsers = parser.add_subparsers(dest="harness", metavar="HARNESS", required=True)
+    for harness in HARNESSES:
+        sub = subparsers.add_parser(
+            harness,
+            allow_abbrev=False,
+            help=f"run {harness}",
+            description=f"Run {harness} non-interactively and print its final message.",
+            epilog=(
+                PROMPT_ADVICE + " Arguments after the first '--' are passed to the harness "
+                "verbatim."
+            ),
+        )
+        sub.add_argument(
+            "prompt",
+            metavar="PROMPT",
+            nargs="?",
+            help="the prompt text, or '-' to read the prompt from stdin",
+        )
+        sub.add_argument("-f", "--prompt-file", metavar="PATH", help="read the prompt from a file")
+        sub.add_argument("-m", "--model", metavar="MODEL", help="model, passed verbatim")
+        sub.add_argument("-e", "--effort", choices=EFFORT_LEVELS, help="effort level")
+        sub.add_argument(
+            "-C", "--cwd", metavar="DIR", help="directory the harness runs in (default: here)"
+        )
+        sub.add_argument(
+            "--autonomous",
+            action="store_true",
+            help="lift run-harness's read-only restrictions",
+        )
+    return parser
+
+
+def _decode(data: bytes, source: str) -> str:
+    try:
+        return data.decode("utf-8")
+    except UnicodeDecodeError as exc:
+        raise UsageError(f"prompt from {source} is not valid UTF-8: {exc.reason}") from None
+
+
+def _read_prompt(args: argparse.Namespace, stdin: BinaryIO, caller_cwd: str) -> str:
+    use_stdin = args.prompt == "-"
+    has_text = args.prompt is not None and not use_stdin
+    sources = [has_text, use_stdin, args.prompt_file is not None]
+    if sum(sources) == 0:
+        raise UsageError("no prompt: give PROMPT, '-' for stdin, or -f PATH")
+    if sum(sources) > 1:
+        raise UsageError("give exactly one prompt source: PROMPT, '-' for stdin, or -f PATH")
+
+    if use_stdin:
+        source = "stdin"
+        text = _decode(stdin.read(), source)
+    elif has_text:
+        source = "argument"
+        # argv arrives as str via surrogateescape; invalid UTF-8 shows up as lone surrogates.
+        try:
+            data = args.prompt.encode("utf-8")
+        except UnicodeEncodeError:
+            raise UsageError("prompt from argument is not valid UTF-8") from None
+        text = _decode(data, source)
+    else:
+        path = args.prompt_file
+        if path == "-":
+            raise UsageError("--prompt-file - is not supported; use PROMPT '-' to read stdin")
+        full = os.path.abspath(os.path.join(caller_cwd, path))
+        source = f"file {full}"
+        if os.path.isdir(full):
+            raise UsageError(f"prompt file {full} is a directory")
+        try:
+            with open(full, "rb") as handle:
+                data = handle.read()
+        except OSError as exc:
+            raise UsageError(f"cannot read prompt file {full}: {exc.strerror}") from None
+        text = _decode(data, source)
+
+    if not text.strip():
+        raise UsageError(f"prompt from {source} is empty")
+    return text
+
+
+def parse_request(
+    argv: Sequence[str],
+    *,
+    stdin: BinaryIO | None = None,
+    cwd: str | None = None,
+) -> RunRequest:
+    """Turn argv (without the program name) into a validated RunRequest.
+
+    `stdin` (a binary stream) and `cwd` (the caller's working directory) are injectable.
+    Raises UsageError on any usage or validation error.
+    """
+    argv = list(argv)
+    passthrough: tuple[str, ...] = ()
+    if "--" in argv:
+        split = argv.index("--")
+        argv, passthrough = argv[:split], tuple(argv[split + 1 :])
+
+    args = build_parser().parse_args(argv)
+    caller_cwd = os.getcwd() if cwd is None else cwd
+    if stdin is None:
+        stdin = sys.stdin.buffer
+
+    prompt = _read_prompt(args, stdin, caller_cwd)
+
+    cap = MAX_PROMPT_BYTES.get(args.harness)
+    if cap is not None:
+        size = len(prompt.encode("utf-8"))
+        if size > cap:
+            raise UsageError(f"prompt is {size} bytes; {args.harness} accepts at most {cap} bytes")
+
+    if args.model is not None and args.model == "":
+        raise UsageError("--model must not be empty")
+
+    run_cwd = os.path.abspath(os.path.join(caller_cwd, args.cwd if args.cwd is not None else "."))
+    if not os.path.exists(run_cwd):
+        raise UsageError(f"--cwd {run_cwd} does not exist")
+    if not os.path.isdir(run_cwd):
+        raise UsageError(f"--cwd {run_cwd} is not a directory")
+
+    return RunRequest(
+        harness=args.harness,
+        prompt=prompt,
+        model=args.model,
+        effort=args.effort,
+        cwd=run_cwd,
+        autonomous=args.autonomous,
+        passthrough=passthrough,
+    )
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    try:
+        request = parse_request(sys.argv[1:] if argv is None else argv)
+    except UsageError as exc:
+        print(f"run-harness: error: {exc}", file=sys.stderr)
+        return 2
+    from run_harness.runner import run
+
+    return run(request)

run_harness/request.py

@@ -0,0 +1,30 @@
+"""Validated run request shared by the CLI and the harness adapters."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+HARNESSES = ("claude", "codex", "pi", "opencode")
+
+# Known maximum prompt size in UTF-8 bytes, keyed by harness. Harnesses without
+# a known limit are not checked.
+MAX_PROMPT_BYTES: dict[str, int] = {"claude": 10 * 1024 * 1024}
+
+
+class UsageError(Exception):
+    """A usage or validation error. The CLI reports it and exits 2."""
+
+
+class HelperNotFound(Exception):
+    """A pre-launch check helper is not on PATH. The runner reports it and exits 127."""
+
+
+@dataclass(frozen=True)
+class RunRequest:
+    harness: str
+    prompt: str
+    model: str | None
+    effort: str | None
+    cwd: str  # absolute
+    autonomous: bool
+    passthrough: tuple[str, ...]

run_harness/runner.py

@@ -0,0 +1,102 @@
+"""Spawn a harness, feed its stdin, pump its stdout and apply the exit rules (spec 3, 5)."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import threading
+from typing import BinaryIO
+
+from run_harness.adapters import ADAPTERS
+from run_harness.adapters.base import (
+    FinalMessage,
+    ProgressWriter,
+    StreamFailure,
+    ensure_newline,
+    resolve_executable,
+)
+from run_harness.request import HelperNotFound, RunRequest, UsageError
+
+
+def _write_prompt(pipe: BinaryIO, data: bytes) -> None:
+    try:
+        pipe.write(data)
+    except OSError:  # BrokenPipeError: the harness stopped reading
+        pass
+    finally:
+        try:
+            pipe.close()
+        except OSError:
+            pass
+
+
+def _failure_code(returncode: int) -> int | None:
+    """Exit code for a failed child, or None when the child exited 0."""
+    if returncode < 0:
+        return 128 - returncode
+    return returncode or None
+
+
+def run(request: RunRequest) -> int:
+    """Run the harness. Exit codes: UsageError is 2, HelperNotFound is 127."""
+    try:
+        return _run(request)
+    except UsageError as exc:
+        print(f"run-harness: error: {exc}", file=sys.stderr)
+        return 2
+    except HelperNotFound as exc:
+        print(f"run-harness: error: {exc}", file=sys.stderr)
+        return 127
+
+
+def _run(request: RunRequest) -> int:
+    adapter = ADAPTERS[request.harness]
+    # First build: only for the env and the executable the precheck runs against.
+    argv, env = adapter.build(request, os.environ)
+    resolved = resolve_executable(argv[0], env)
+    facts = adapter.precheck(request, env)
+    # The argv can depend on what the precheck found (e.g. Pi's major version).
+    argv, env = adapter.build(request, os.environ, facts)
+
+    handler = adapter.new_stream_handler(sys.stderr)
+    proc = subprocess.Popen(
+        argv,
+        executable=resolved,
+        cwd=request.cwd,
+        env=env,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=None,
+    )
+    assert proc.stdin is not None and proc.stdout is not None
+    writer = threading.Thread(
+        target=_write_prompt, args=(proc.stdin, request.prompt.encode("utf-8")), daemon=True
+    )
+    writer.start()
+    try:
+        for raw in proc.stdout:
+            handler.feed(raw.decode("utf-8", errors="surrogateescape"))
+        returncode = proc.wait()
+    finally:
+        if proc.poll() is None:
+            proc.kill()
+            proc.wait()
+        proc.stdout.close()
+    writer.join()
+
+    # Finish the handler even when the harness failed: error text extracted from the
+    # stream (e.g. Claude's not-logged-in result, rc 1) still belongs on stderr.
+    outcome = handler.finish()
+    failed = _failure_code(returncode)
+    if isinstance(outcome, StreamFailure):
+        ProgressWriter(sys.stderr).text(outcome.error_text)
+        return 1 if failed is None else failed
+    if failed is not None:
+        return failed
+    assert isinstance(outcome, FinalMessage)
+    text = outcome.text
+    if text:
+        sys.stdout.buffer.write(ensure_newline(text).encode("utf-8", "surrogateescape"))
+        sys.stdout.buffer.flush()
+    return 0

run_harness-0.1.0.dist-info/METADATA

@@ -0,0 +1,254 @@
+Metadata-Version: 2.3
+Name: run-harness
+Version: 0.1.0
+Summary: One CLI for launching coding-agent harnesses non-interactively.
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# run-harness
+
+`run-harness` launches one coding-agent harness (Claude Code, Codex, Pi or OpenCode)
+non-interactively, through one set of options, and prints the harness's final message on stdout.
+It builds the command line, starts the harness, extracts the answer and maps the exit code. It is
+not an agent runtime, and it never reads or writes harness config files.
+
+Callers are mostly other programs that run it as a subprocess, plus people at a terminal. There is
+no Python library API. The detailed contract is in [docs/spec.md](docs/spec.md).
+
+Supported: Linux and macOS, Python 3.12+. Windows is not supported.
+
+## Install and use
+
+```sh
+uvx run-harness claude "Summarise the architecture of this repo"
+uvx run-harness codex "List the public functions in src/" -m gpt-5-codex -e high
+uvx run-harness pi "Where is the config parsed?" -C ~/code/project
+uvx run-harness opencode "Explain the build" -m anthropic/claude-sonnet-4-5 -e high
+```
+
+You can also install it with `uv tool install run-harness`. The harness itself (`claude`, `codex`,
+`pi`, `opencode`) must already be installed, logged in and on `PATH`. run-harness passes the
+environment and auth through untouched.
+
+```
+run-harness <harness> [PROMPT] [-m MODEL] [-e {low,medium,high,max}] [-f PATH] [-C DIR] [--autonomous] [-- PASSTHROUGH...]
+run-harness --version | --help
+run-harness <harness> --help
+```
+
+Only the final message goes to stdout, with a trailing newline added if it is missing. Progress and
+diagnostics go to stderr.
+
+| option | meaning |
+|---|---|
+| `PROMPT` | the prompt text, or `-` to read the prompt from run-harness's own stdin |
+| `-f, --prompt-file PATH` | read the prompt from a file |
+| `-m, --model MODEL` | model, passed verbatim and never validated |
+| `-e, --effort LEVEL` | `low`, `medium`, `high` or `max`. If omitted, the harness default applies |
+| `-C, --cwd DIR` | directory the harness runs in (default: the current directory) |
+| `--autonomous` | lift the read-only restrictions |
+| `-- …` | passthrough arguments, handed to the harness verbatim |
+
+Options may come before or after `PROMPT`. An unknown option before `--` is an error (exit 2).
+Abbreviated long options are not accepted. `--model ""` is an error.
+
+### Prompt source
+
+Give exactly one of: `PROMPT`, `PROMPT` = `-` (read stdin), or `-f PATH`. None, or more than one,
+is exit 2. Empty or whitespace-only prompts and prompts that are not valid UTF-8 are exit 2. A
+Claude Code prompt over 10 MiB is rejected. No other harness limit is checked.
+
+- run-harness reads its own stdin only when `PROMPT` is `-`. `-f -` is rejected.
+- `-f PATH` is resolved against the directory you ran run-harness from, not `--cwd`. FIFOs and
+  process substitution (`-f <(...)`) work. Directories are rejected.
+- The prompt reaches the harness on its stdin, never as an argv argument. It is passed verbatim.
+- A prompt starting with `-` cannot be given as `PROMPT`. **Send untrusted text, and anything that
+  starts with `-`, through `-f` or stdin:**
+
+```sh
+printf '%s' "$UNTRUSTED" | uvx run-harness claude -
+uvx run-harness codex -f prompt.md
+```
+
+### Working directory
+
+`--cwd` must exist and be a directory. It is made absolute without resolving symlinks, and it is
+applied both as the harness's working directory and as `PWD` in its environment. No harness gets
+its own directory flag (`codex -C`, `opencode --dir`).
+
+### Passthrough
+
+Everything after the first `--` is appended after the arguments run-harness generates, and is never
+inspected:
+
+```sh
+uvx run-harness claude "Review this" -- --max-turns 5
+```
+
+Conflicts with the normalized options are your responsibility. See "do not override" below. If an
+override breaks final-message extraction, the run exits 1.
+
+## Read-only and autonomous
+
+Read-only is the default. The model may read and reason, but cannot change files or reach the
+network. It may run a command only where a sandbox stops that command from writing (Codex).
+`--autonomous`
+lifts that and permits writes, command execution and network access, in whatever way each harness
+does it (see the table below).
+
+The limits matter:
+
+- run-harness only sets the harness's own flags. It does not sandbox anything itself.
+- **Hooks and extensions still run.** User and project hooks run in Claude Code's read-only mode,
+  and Pi extensions still load and run their hooks. Only the tools are restricted.
+- **User deny rules still apply** under `--autonomous` (Claude Code `deny` settings, deny rules in
+  the OpenCode config).
+- **Codex read-only still lets the model run commands.** They run inside a sandbox that blocks
+  writes and network access.
+- Pi has no permission system. Its read-only mode is a tool allowlist.
+- A permission that is blocked in read-only mode is not an error. OpenCode ends such a run with
+  exit 0.
+- Org, managed or MDM OpenCode config merges after the config run-harness injects.
+
+## Per-harness mapping
+
+| | Claude Code | Codex | Pi | OpenCode |
+|---|---|---|---|---|
+| base command | `claude -p --output-format stream-json --verbose` | `codex exec --skip-git-repo-check --color never` | `pi --mode json` | `opencode run --standalone --format json` |
+| prompt | stdin | stdin | stdin | stdin |
+| `--model M` | `--model M` | `-m M` | `--model M` | `-m M` |
+| `--effort L` | `--effort L` | `-c model_reasoning_effort=L` | `--thinking L` | `-m M#L` (pre-checked) |
+| read-only (default) | `--tools Read,Grep,Glob --permission-mode dontAsk --strict-mcp-config` | `-s read-only` | `--tools read,grep,find,ls` (plus `--no-mcp` on Pi 1.x and later) | injected agent plus `--agent run-harness-readonly` (pre-checked with `opencode api`) |
+| `--autonomous` | `--dangerously-skip-permissions` | `--dangerously-bypass-approvals-and-sandbox` | nothing added | `--auto` |
+| final message | `result` of the last `result` event | captured stdout | text of the last assistant `message_end` | text parts of the last assistant message |
+| failure despite exit 0 | `is_error: true`, or no `result` | none | `stopReason` is `error` or `aborted` | an `error` event |
+| do not override | `-p`, `--output-format`, `--verbose`, `--tools`, `--permission-mode` | `-s`, `--color`, `--json`, `-o` | `--mode`, `--tools`, `-p` | `--format`, `--agent`, `--dir` |
+
+Argument order is: base command, permission arguments, `--model`, effort, passthrough.
+
+### Claude Code
+
+- `CLAUDE_CODE_EFFORT_LEVEL` passes through untouched. Whether it or `--effort` wins is unverified.
+- A user `maxEffortLevel` setting can silently cap `max`.
+- Read-only uses a tool allowlist, not `plan` mode, and `--strict-mcp-config` drops MCP servers from
+  user and project config. Hooks still run.
+- Bypass mode refuses to run as root outside a sandbox. That refusal comes through with Claude's
+  exit code.
+- An auth failure (`Not logged in`) exits 1 with the message on stderr.
+
+### Codex
+
+- Codex's stdout, when piped, is the final message. It is buffered and written once at the end.
+  Its stderr is its own progress, forwarded unchanged.
+- `-s read-only` is always passed explicitly. Projects marked `trusted` in `~/.codex/config.toml`
+  would otherwise default to `workspace-write`.
+- An unknown model makes Codex warn ("fallback metadata") and fail the turn, so the run exits 1.
+- There is no auth pre-check. An auth failure exits 1 after roughly 15 to 20 seconds of retries.
+
+### Pi
+
+- Before a read-only run, run-harness runs `pi --version`. Pi 1.x and later gets `--no-mcp`,
+  because `--tools` keeps MCP tools otherwise. Pi 0.x does not get it, since the flag does not
+  exist there. Unparseable output or a non-zero exit is exit 2, because read-only cannot be
+  guaranteed. `--autonomous` skips the check.
+- `--thinking` is clamped silently per model.
+- A `:<thinking>` suffix on `--model` is overridden by an explicit `--effort`.
+- Extensions still load and run their hooks in read-only mode. Only their tools are hidden.
+- Passthrough positional arguments starting with `@` become file attachments.
+- Pi exits 0 when the model errors in JSON mode. run-harness turns that into exit 1.
+
+### OpenCode
+
+- Read-only injects an agent named `run-harness-readonly` through `OPENCODE_CONFIG_CONTENT`. It is
+  merged into your value if you set one, and invalid JSON there is exit 2. The agent allows only
+  `read`, `glob`, `grep`, `list` and `lsp`, and denies everything else, including `task`. Nothing
+  is persisted. Apart from `PWD`, this is the only environment variable run-harness changes.
+- Supports OpenCode 2.x only. Every run passes `--standalone`: 2.x otherwise talks to a shared
+  background service that never sees the injected config, so the agent would be missing.
+- Before launch, `opencode api --standalone GET /api/config` (same env and cwd) must show the
+  agent with exactly the injected permissions (otherwise exit 2). If a run still cannot load the
+  agent, OpenCode reports `Agent not found` and run-harness exits non-zero with nothing on stdout.
+- **`--effort` requires `--model` in `provider/model` form.** run-harness passes it as
+  `-m provider/model#level` and first reads `opencode api --standalone GET /api/model`. It exits 2
+  if the model is not listed, has no variants, or the level is not one of its variants.
+- **The model is validated only when `--effort` is given.** Without `--effort`, an unlisted model
+  fails at run time, and the run exits 1.
+- A permission rejected in read-only mode ends the run with exit 0.
+- OpenCode creates `.opencode/.gitignore` and installs its plugin package at startup. Those are its
+  own side effects.
+
+### Effort
+
+`low`, `medium`, `high` and `max` map one to one onto every harness, with no remapping (`max` is
+never turned into `xhigh`). Claude Code, Codex and Pi adjust a level the model does not support to
+the nearest one it does, and run-harness does not detect that. OpenCode rejects unknown variants
+at run time, but run-harness checks them first so you get exit 2 and the valid levels. Native-only levels (`xhigh`, `minimal`, `off`, `none`
+and so on) are reachable only through passthrough.
+
+## Exit codes
+
+| situation | exit | stdout |
+|---|---|---|
+| usage or validation error, or a failed pre-launch check | `2` | empty |
+| harness executable (or a pre-check helper) not on `PATH` | `127` | empty |
+| harness exits non-zero | the harness's code, verbatim | empty |
+| harness killed by signal N | `128 + N` | empty |
+| harness exits 0, but the event stream reports an error | `1` | empty |
+| harness exits 0 with no final-message event | `1` | empty |
+| harness exits 0 with a final message | `0` | the final message |
+| harness exits 0 with an empty final message | `0` | empty (no newline added) |
+| Codex exits 0 | `0` | the captured stdout |
+
+stdout is written once, after the harness exits, and only when run-harness exits 0. On failure,
+error text taken from the stream goes to stderr.
+
+## stderr
+
+stderr is for people. Its format is not stable and is not a contract. The harness's own stderr is
+forwarded unchanged. For Claude Code, Pi and OpenCode, run-harness also prints the assistant text
+and a `→ tool: <name>` line per tool call as events arrive. Lines that are not JSON are forwarded
+raw. Codex has no renderer, since its stderr already is its progress.
+
+## Tested harness versions
+
+run-harness declares tested versions, not minimums. The fixtures come from these versions run
+against a local fake model server (OpenCode: observed on 2.0.32 with a free model), plus
+hand-written edge cases. Claude Code's and OpenCode's `success` and `tool_call` fixtures, and
+Claude Code's `not_logged_in`, are recorded against a real model with the recorder script below.
+Codex was checked with the live suite:
+
+| harness | version |
+|---|---|
+| Claude Code | 2.1.303 |
+| Codex | codex-cli 0.163.0 |
+| Pi | 0.85.1 |
+| OpenCode | 2.0.32 (2.x only) |
+
+There are no general runtime version checks. The one exception is Pi's `--no-mcp`, because a
+version difference there would make read-only fail open. Other versions may work, or may break
+extraction. The opt-in live suite (below) is how drift is detected.
+
+## Development
+
+```sh
+uv run pytest                       # unit and fake-harness tests; no real harness needed
+uv run ruff check
+uv run ruff format --check
+uv run pytest -m live               # opt-in smoke run against the real harnesses on PATH
+uv run scripts/record_fixtures.py   # re-record the fixtures from the real harnesses
+```
+
+The live suite never runs in CI. Run it locally before a release, and re-record the fixtures if it
+fails.
+
+## Release
+
+Releases run from the Actions tab: run the **Release** workflow on `master`, choosing a version
+`bump` (`none` releases the version already in `pyproject.toml`) and whether to publish to `pypi`.
+
+The workflow runs lint and tests, applies the bump and builds, refusing a version that is already
+tagged. It publishes to TestPyPI and smoke-tests the install on Linux and macOS
+(`scripts/smoke_release.sh`). With `pypi` ticked it then publishes the same files to PyPI, commits
+the bump, tags `vX.Y.Z`, creates a GitHub Release with generated notes and smoke-tests the PyPI
+install. With `pypi` unticked it stops after TestPyPI, as a dry run. Both indexes use trusted
+publishing for `release.yml`, with no environment.

run_harness-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+run_harness/__init__.py,sha256=mWgtTOOSvrg7sntYi2jCCzuYbB8WdWAk1xz6KtQ0Hdk,55
+run_harness/__main__.py,sha256=PtAfSwJBtzEWRzoF1Qmm4KdBi5W18zVxnuneXpmU3WQ,59
+run_harness/adapters/__init__.py,sha256=rT20RhVy3OVAj0bE2R2A6H3J5RPasnJgBq9jOso8sc0,490
+run_harness/adapters/base.py,sha256=zBPGRtvBHUD-Dpx2ajxU-jYY-Ya7GC5Hn1M4S98dOlc,5187
+run_harness/adapters/claude.py,sha256=9kwuh3ABftPqz0JQKuQUQBu9CsbIFv4jCisbVzXduVQ,3605
+run_harness/adapters/codex.py,sha256=3y2A3Qc820CLEf2yN4wvG7TuD-Z4dkCB3KEuaPagEG4,1438
+run_harness/adapters/opencode.py,sha256=GlYR5-hM_WAB8LmZWwYBi6fPjbShRDwyJojTUa2U31o,10013
+run_harness/adapters/pi.py,sha256=nOSMP1CvOuhUKnc3wDPxA4IDma0s5f95vusYP1NZ9Lk,3906
+run_harness/cli.py,sha256=SXGA33en_ky6wY9J61R562eKojtyQJaOl5cifSzlpyw,6387
+run_harness/request.py,sha256=aBeeFK_rPuxoBxIU7YI6E1s-2_-zkL-TU9_nJhw2WIs,799
+run_harness/runner.py,sha256=1qm5G0oZeCKeRfmPloGGTs0lz5NMFzfF8-FnuCinJoM,3174
+run_harness-0.1.0.dist-info/WHEEL,sha256=3NO1oYsF7mANFUWVdyEQLM-zmecczWWEmmF5rEbXrWk,80
+run_harness-0.1.0.dist-info/entry_points.txt,sha256=_Mzhp1zT2ysEqnEwkC-i2jBRNKuW3rcFOxyFdXqeGcM,54
+run_harness-0.1.0.dist-info/METADATA,sha256=mzOJoL2zizK_EFUy957dYDblRXDiPeD-ILyxrycag_Y,13394
+run_harness-0.1.0.dist-info/RECORD,,

run_harness-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.13.6
+Root-Is-Purelib: true
+Tag: py3-none-any

run_harness-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+run-harness = run_harness.cli:main
+