@rulemetric/cli 0.12.8 → 0.14.0

package/dist/harbor/mcp_container_shell.py

@@ -0,0 +1,156 @@
+"""Dependency-free MCP stdio server exposing one tool: `bash`, executed
+INSIDE the Harbor trial container.
+
+This is a tool proxy, not a network proxy: the host Claude Code's own Bash
+tool is disabled by the agent, and every shell command is routed here, run
+via `docker exec` in the task container. Around each command the host
+workdir and the container's /app are synced with tar pipes (docker cp has no
+excludes; the injected CLAUDE.md and .claude/ must never reach the
+container).
+
+Config via env: RM_CONTAINER_ID (docker container id), RM_WORKDIR (host dir
+mirroring /app).
+"""
+
+import json
+import os
+import subprocess
+import sys
+
+CONTAINER = os.environ["RM_CONTAINER_ID"]
+WORKDIR = os.environ["RM_WORKDIR"]
+SYNC_EXCLUDES = ["CLAUDE.md", ".claude"]
+DEFAULT_TIMEOUT = 120
+MAX_OUTPUT = 30_000
+
+TOOL = {
+    "name": "bash",
+    "description": (
+        "Run a shell command inside the task container (bash -lc). This is "
+        "the ONLY shell for this task: the host Bash tool is disabled. Files "
+        "edited with file tools are synced into the container before the "
+        "command runs, and container file changes are synced back after."
+    ),
+    "inputSchema": {
+        "type": "object",
+        "properties": {
+            "command": {"type": "string", "description": "Shell command to run"},
+            "timeout_sec": {
+                "type": "number",
+                "description": f"Seconds before the command is killed (default {DEFAULT_TIMEOUT})",
+            },
+        },
+        "required": ["command"],
+    },
+}
+
+
+def _sync_to_container() -> None:
+    tar = subprocess.Popen(
+        ["tar", "-C", WORKDIR]
+        + [f"--exclude=./{e}" for e in SYNC_EXCLUDES]
+        + ["-cf", "-", "."],
+        stdout=subprocess.PIPE,
+    )
+    subprocess.run(
+        ["docker", "exec", "-i", CONTAINER, "tar", "-C", "/app", "-xf", "-"],
+        stdin=tar.stdout,
+        check=True,
+        capture_output=True,
+    )
+    tar.wait()
+
+
+def _sync_from_container() -> None:
+    tar = subprocess.Popen(
+        ["docker", "exec", CONTAINER, "tar", "-C", "/app", "-cf", "-", "."],
+        stdout=subprocess.PIPE,
+    )
+    subprocess.run(
+        ["tar", "-C", WORKDIR, "-xf", "-"],
+        stdin=tar.stdout,
+        check=True,
+        capture_output=True,
+    )
+    tar.wait()
+
+
+def _run_bash(command: str, timeout_sec: float) -> str:
+    _sync_to_container()
+    try:
+        proc = subprocess.run(
+            ["docker", "exec", "-w", "/app", CONTAINER, "bash", "-lc", command],
+            capture_output=True,
+            text=True,
+            timeout=timeout_sec,
+        )
+        out = proc.stdout[-MAX_OUTPUT:]
+        err = proc.stderr[-MAX_OUTPUT:]
+        result = f"[exit_code] {proc.returncode}"
+        if out:
+            result = f"[stdout]\n{out}\n{result}"
+        if err:
+            result = f"{result}\n[stderr]\n{err}"
+    except subprocess.TimeoutExpired:
+        result = f"[error] command timed out after {timeout_sec}s"
+    _sync_from_container()
+    return result
+
+
+def _respond(msg_id, result=None, error=None) -> None:
+    resp = {"jsonrpc": "2.0", "id": msg_id}
+    if error is not None:
+        resp["error"] = error
+    else:
+        resp["result"] = result
+    sys.stdout.write(json.dumps(resp) + "\n")
+    sys.stdout.flush()
+
+
+def main() -> None:
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        msg = json.loads(line)
+        method, msg_id = msg.get("method"), msg.get("id")
+        if method == "initialize":
+            _respond(
+                msg_id,
+                {
+                    "protocolVersion": msg["params"].get(
+                        "protocolVersion", "2024-11-05"
+                    ),
+                    "capabilities": {"tools": {}},
+                    "serverInfo": {"name": "container", "version": "0.1.0"},
+                },
+            )
+        elif method == "tools/list":
+            _respond(msg_id, {"tools": [TOOL]})
+        elif method == "tools/call":
+            args = msg["params"].get("arguments", {})
+            try:
+                text = _run_bash(
+                    args["command"],
+                    float(args.get("timeout_sec") or DEFAULT_TIMEOUT),
+                )
+                _respond(
+                    msg_id,
+                    {"content": [{"type": "text", "text": text}], "isError": False},
+                )
+            except Exception as exc:  # sync/docker failures reach the model as text
+                _respond(
+                    msg_id,
+                    {
+                        "content": [{"type": "text", "text": f"[proxy error] {exc}"}],
+                        "isError": True,
+                    },
+                )
+        elif method == "ping":
+            _respond(msg_id, {})
+        elif msg_id is not None:  # unknown request; notifications are ignored
+            _respond(msg_id, error={"code": -32601, "message": f"unknown: {method}"})
+
+
+if __name__ == "__main__":
+    main()

package/dist/harbor/provenance.py

@@ -0,0 +1,361 @@
+#!/usr/bin/env python3
+"""What harness measured a Harbor job — and whether two jobs are comparable.
+
+Two arms are a valid A/B only if the only thing that differed between them is
+the instruction. Everything else that CAN differ and change the numbers is a
+pooling key here, recorded per trial and checked before any verdict.
+
+Origin (2026-09-02). The 2026-08-31 scorecard recorded `rm-pagination-task`
+baseline at 2/10; the 2026-09-02 re-measurement got 25/25. The cause was
+`--allowedTools Bash` landing in #415 between them: the "failures" were largely
+the agent stalling on an unapproved Bash command, not computing a wrong
+aggregate. Nothing in either job dir recorded the regime, so for two days a
+HARNESS change read as the rule having stopped working. scripts/harbor/README.md
+item 7 already stated the rule -- "runs made under different permission regimes
+are different harnesses" -- as prose, and prose does not refuse.
+
+This module is the single owner of that rule. `cost_delta.py` and
+`verdict_bridge.py` import it; the scheduled TypeScript path SHELLS OUT to
+`--compare` rather than re-deriving POOLING_KEYS, because a hand-copied
+predicate is how the canonical-checkout, judge-segment and auto-accept defects
+each shipped (CLAUDE.md hard invariants).
+
+Stdlib only, and importable without `harbor` installed, so the contract test can
+exercise every path on synthetic job dirs.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, Iterable, Sequence
+
+# The keys that make two runs different harnesses. A difference on any of these
+# means the arms are not an A/B of the instruction, whatever the numbers say.
+POOLING_KEYS = ("engine", "engine_version", "model", "permission_regime", "billing")
+
+# Flags that define the permission regime, in a FIXED order so the regime string
+# does not change when the command builder reorders its argv. Read from the
+# actual argv rather than a constant in this file: a regime hardcoded here could
+# never notice the change it exists to catch.
+_REGIME_VALUE_FLAGS = (
+    "--permission-mode",
+    "--allowedTools",
+    "--sandbox",
+    "--ask-for-approval",
+    "--approval-mode",
+)
+_REGIME_BOOL_FLAGS = (
+    "--dangerously-skip-permissions",
+    "--full-auto",
+    "--yolo",
+)
+
+# Presence of a credential is a FACT about the run and belongs in the stamp; the
+# credential itself never does. Harbor records agent env verbatim in each trial's
+# config.json, so anything written here is written next to that.
+_BYOK_VARS = ("ANTHROPIC_API_KEY", "CLAUDE_CODE_OAUTH_TOKEN")
+
+STAMP_FILENAME = "rm-provenance.json"
+FORMAT_VERSION = 1
+
+
+def _flag_value(argv: Sequence[str], flag: str) -> str | None:
+    """The value following `flag`, or None. Supports `--flag=value` too."""
+    for i, token in enumerate(argv):
+        if token == flag:
+            return argv[i + 1] if i + 1 < len(argv) else None
+        if token.startswith(flag + "="):
+            return token.split("=", 1)[1]
+    return None
+
+
+def permission_regime(argv: Sequence[str]) -> str:
+    """The regime as a stable string, e.g. 'acceptEdits+Bash'.
+
+    'unspecified' when the argv names no regime at all -- which is itself a
+    distinguishing fact, not a missing value: a run with no stated regime and a
+    run with `acceptEdits` are different harnesses.
+    """
+    parts: list[str] = []
+    for flag in _REGIME_VALUE_FLAGS:
+        value = _flag_value(argv, flag)
+        if value:
+            # A comma list is normalised so tool ORDER cannot fork the string.
+            parts.append("+".join(sorted(v.strip() for v in value.split(",") if v.strip())))
+    parts.extend(flag.lstrip("-") for flag in _REGIME_BOOL_FLAGS if flag in argv)
+    return "+".join(parts) if parts else "unspecified"
+
+
+def stamp(
+    argv: Sequence[str],
+    *,
+    observed_model: str | None = None,
+    engine: str | None = None,
+    engine_version: str | None = None,
+    env: dict[str, str] | None = None,
+    delivery: Iterable[str] | None = None,
+) -> dict[str, Any]:
+    """The per-trial provenance record, written beside the agent's output.
+
+    `observed_model` is what the run REPORTS having billed (claude's
+    `modelUsage`); it outranks the `--model` flag, because a credit-exhaustion
+    fallback silently swaps the model while the flag still says haiku -- the
+    same failure that orphaned the judge segment (CLAUDE.md). When nothing
+    observed the model, that is stated (`model_source: 'requested'`) rather than
+    presented as if it had been.
+    """
+    argv = list(argv)
+    environ = os.environ if env is None else env
+    requested = _flag_value(argv, "--model") or _flag_value(argv, "-m")
+    if engine is None and argv:
+        engine = Path(argv[0]).name or None
+    return {
+        "format_version": FORMAT_VERSION,
+        "engine": engine,
+        "engine_version": engine_version,
+        "model": observed_model or requested,
+        "model_requested": requested,
+        "model_source": "observed" if observed_model else ("requested" if requested else "unknown"),
+        "permission_regime": permission_regime(argv),
+        "billing": "byok" if any(environ.get(v) for v in _BYOK_VARS) else "subscription",
+        "delivery": sorted(delivery) if delivery else [],
+    }
+
+
+def observed_model_from_claude(output: str | bytes) -> str | None:
+    """The model(s) a `claude -p --output-format json` envelope reports billing.
+
+    None when the envelope says nothing -- unknown, never a guess. Two keys is
+    NOT one model: the run fell back mid-flight, and a stamp that reported only
+    the first would call that the same harness as a clean single-model run, which
+    is the credit-exhaustion shape that orphaned the judge segment.
+    """
+    if isinstance(output, bytes):
+        output = output.decode("utf-8", errors="replace")
+    try:
+        envelope = json.loads(output)
+    except (ValueError, TypeError):
+        return None
+    usage = envelope.get("modelUsage") if isinstance(envelope, dict) else None
+    if not isinstance(usage, dict) or not usage:
+        return None
+    return "+".join(sorted(str(k) for k in usage))
+
+
+_CLI_VERSION_CACHE: dict[str, str | None] = {}
+
+
+def cli_version(binary: str) -> str | None:
+    """`<binary> --version`, cached per process. None when it cannot be read.
+
+    This is the version that CHANGES under a scheduled run on someone else's
+    machine, which is what makes it a pooling key -- unlike the agent module's
+    own version, recorded separately as `agent_version`.
+    """
+    if binary not in _CLI_VERSION_CACHE:
+        import subprocess  # local: keeps the module importable in odd sandboxes
+
+        try:
+            proc = subprocess.run(
+                [binary, "--version"], capture_output=True, text=True, timeout=20
+            )
+            out = (proc.stdout or proc.stderr or "").strip()
+            _CLI_VERSION_CACHE[binary] = out.splitlines()[0].strip() if out else None
+        except (OSError, subprocess.SubprocessError):
+            _CLI_VERSION_CACHE[binary] = None
+    return _CLI_VERSION_CACHE[binary]
+
+
+def write_stamp(agent_dir: Path, record: dict[str, Any]) -> Path:
+    """Write a stamp beside a trial's agent output. Never raises into the run.
+
+    A run that produced real work must not be destroyed by a failure to record
+    what produced it; an unstamped job is refused later by name, which is the
+    safe direction.
+    """
+    path = Path(agent_dir) / STAMP_FILENAME
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(record, indent=2, sort_keys=True))
+    except OSError as exc:  # pragma: no cover - defensive
+        print(f"provenance: could not write {path}: {exc}", file=sys.stderr)
+    return path
+
+
+def read_job(job_dir: str | Path) -> dict[str, Any]:
+    """Merge a job's per-trial stamps into one, or report which key disagrees.
+
+    A job whose own trials disagree is NOT a job: its mean already pools two
+    harnesses, so no single stamp can describe it and `provenance` is None.
+    """
+    job_dir = Path(job_dir)
+    values: dict[str, set[str]] = {k: set() for k in POOLING_KEYS}
+    stamped = 0
+    for path in sorted(job_dir.rglob(STAMP_FILENAME)):
+        try:
+            record = json.loads(path.read_text())
+        except (OSError, ValueError):
+            continue
+        if not isinstance(record, dict):
+            continue
+        stamped += 1
+        for key in POOLING_KEYS:
+            value = record.get(key)
+            if value is not None:
+                values[key].add(str(value))
+
+    mixed = [k for k in POOLING_KEYS if len(values[k]) > 1]
+    provenance: dict[str, Any] | None = None
+    if stamped and not mixed:
+        provenance = {k: (next(iter(values[k])) if values[k] else None) for k in POOLING_KEYS}
+    return {"provenance": provenance, "mixed": mixed, "trials_stamped": stamped}
+
+
+def compare(
+    baseline_dir: str | Path,
+    with_dir: str | Path,
+    *,
+    allow_cross: Iterable[str] = (),
+    allow_unstamped: bool = False,
+) -> dict[str, Any]:
+    """Are these two job dirs an A/B of the instruction, or of the harness?
+
+    `allow_cross` is the typed exception: a key listed there stops refusing and
+    moves to `pooled_across`, which every caller carries into its verdict, so a
+    cross-harness number can never be quoted as a within-harness one.
+
+    `allow_unstamped` exists only for job dirs measured before stamps existed.
+    It says "I could not verify", never "I verified they match" -- the reason
+    stays on the result either way, so an unverified verdict cannot be quoted as
+    a verified one.
+    """
+    allow = [k for k in allow_cross if k]
+    unknown = [k for k in allow if k not in POOLING_KEYS]
+    arms = {"baseline": read_job(baseline_dir), "with-arm": read_job(with_dir)}
+
+    reasons: list[str] = []
+    unstamped = [label for label, a in arms.items() if a["provenance"] is None and not a["mixed"]]
+    mixed_arms = [label for label, a in arms.items() if a["mixed"]]
+
+    for key in unknown:
+        reasons.append(f"--allow-cross named '{key}', which is not a pooling key ({', '.join(POOLING_KEYS)})")
+    for label in unstamped:
+        reasons.append(
+            f"{label} carries no provenance stamp — unknown provenance is not matching provenance, "
+            + ("so this verdict is UNVERIFIED (--allow-unstamped)" if allow_unstamped
+               else "so this pair is refused rather than assumed comparable")
+        )
+    for label in mixed_arms:
+        keys = ", ".join(arms[label]["mixed"])
+        reasons.append(f"{label} is internally mixed on {keys} — its own trials ran on more than one harness")
+
+    differs: list[str] = []
+    pooled_across: list[str] = []
+    b, w = arms["baseline"]["provenance"], arms["with-arm"]["provenance"]
+    if b and w:
+        for key in POOLING_KEYS:
+            if b.get(key) == w.get(key):
+                continue
+            if key in allow:
+                pooled_across.append(key)
+                reasons.append(f"pooled across {key} ({b.get(key)!r} vs {w.get(key)!r}) by explicit --allow-cross")
+                continue
+            differs.append(key)
+            reasons.append(
+                f"baseline and with-arm differ on {key}: {b.get(key)!r} vs {w.get(key)!r} — "
+                "different harnesses, not different rules"
+            )
+
+    blocking_unstamped = [] if allow_unstamped else unstamped
+    comparable = not (differs or blocking_unstamped or mixed_arms or unknown)
+    if comparable and not reasons:
+        reasons.append("same harness on every pooling key")
+    return {
+        "comparable": comparable,
+        "differs": differs,
+        "pooled_across": pooled_across,
+        "unstamped": unstamped,
+        "allow_unstamped": bool(allow_unstamped),
+        "mixed": mixed_arms,
+        "reasons": reasons,
+        "baseline": b,
+        "with": w,
+        "pooling_keys": list(POOLING_KEYS),
+    }
+
+
+def compare_all(
+    dirs: Sequence[str | Path],
+    *,
+    allow_cross: Iterable[str] = (),
+    allow_unstamped: bool = False,
+) -> dict[str, Any]:
+    """Are ALL of these job dirs one harness?
+
+    `verdict_bridge.py` accepts `--baseline` more than once and sums the counts,
+    so an arm can silently pool two job dirs measured weeks apart. Every dir is
+    compared against the first; one disagreement anywhere refuses the lot.
+    """
+    dirs = [Path(d) for d in dirs]
+    if len(dirs) < 2:
+        only = read_job(dirs[0]) if dirs else {"provenance": None, "mixed": []}
+        unstamped = [] if (only["provenance"] or allow_unstamped) else ["the only job"]
+        return {
+            "comparable": not unstamped and not only["mixed"],
+            "differs": [], "pooled_across": [], "unstamped": unstamped,
+            "mixed": only["mixed"], "reasons": [], "pooling_keys": list(POOLING_KEYS),
+        }
+    merged: dict[str, Any] = {
+        "comparable": True, "differs": [], "pooled_across": [], "unstamped": [],
+        "mixed": [], "reasons": [], "pooling_keys": list(POOLING_KEYS),
+    }
+    for other in dirs[1:]:
+        one = compare(dirs[0], other, allow_cross=allow_cross, allow_unstamped=allow_unstamped)
+        merged["comparable"] = merged["comparable"] and one["comparable"]
+        for key in ("differs", "pooled_across", "unstamped", "mixed"):
+            for value in one[key]:
+                if value not in merged[key]:
+                    merged[key].append(value)
+        for reason in one["reasons"]:
+            if reason not in merged["reasons"] and reason != "same harness on every pooling key":
+                merged["reasons"].append(reason)
+    return merged
+
+
+def pretty(result: dict[str, Any]) -> str:
+    head = "comparable" if result["comparable"] else "INCOMPARABLE"
+    return "\n".join([f"provenance: {head}"] + [f"  - {r}" for r in result["reasons"]])
+
+
+def main(argv: list[str]) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("--compare", nargs=2, metavar=("BASELINE_JOB", "WITH_JOB"))
+    parser.add_argument("--job", metavar="JOB_DIR", help="print one job's merged stamp")
+    parser.add_argument("--allow-cross", default="", help="comma-separated pooling keys to pool across anyway")
+    parser.add_argument("--allow-unstamped", action="store_true", help="proceed on job dirs with no stamp (UNVERIFIED, not verified)")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args(argv[1:])
+
+    if args.job:
+        print(json.dumps(read_job(args.job)))
+        return 0
+    if not args.compare:
+        parser.error("one of --compare or --job is required")
+
+    result = compare(
+        *args.compare,
+        allow_cross=[k.strip() for k in args.allow_cross.split(",")],
+        allow_unstamped=args.allow_unstamped,
+    )
+    print(json.dumps(result) if args.json else pretty(result))
+    # Non-zero on an incomparable pair so a shell caller cannot ignore it by
+    # accident -- the JSON is still on stdout for a caller that wants the keys.
+    return 0 if result["comparable"] else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

package/dist/harbor/rm-batch-task/environment/Dockerfile

@@ -0,0 +1,6 @@
+FROM ubuntu:24.04
+
+RUN apt-get update && apt-get install -y curl ca-certificates git && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+COPY items.jsonl /app/items.jsonl

package/dist/harbor/rm-batch-task/environment/items.jsonl

@@ -0,0 +1,60 @@
+{"id": 1, "qty": 2, "price": 1.5}
+{"id": 2, "qty": 3, "price": 2.0}
+{"id": 3, "qty": 4, "price": 2.5}
+{"id": 4, "qty": 5, "price": 3.0}
+{"id": 5, "qty": 6, "price": 3.5}
+{"id": 6, "qty": 7, "price": 4.0}
+{"id": 7, "qty": 8, "price": 4.5}
+{"id": 8, "qty": 9, "price": 5.0}
+{"id": 9, "qty": 1, "price": 5.5}
+{"id": 10, "qty": 2, "price": 6.0}
+{"id": 11, "qty": 3, "price": 6.5}
+{"id": 12, "qty": 4, "price": 7.0}
+{"id": 13, "qty": 5, "price": 7.5}
+{"id": 14, "qty": 6, "price": 8.0}
+{"id": 15, "qty": 7, "price": 8.5}
+{"id": 16, "qty": 8, "price": 9.0}
+{"id": 17, "qty": 9, "price": 9.5}
+{"id": 18, "qty": 1, "price": 10.0}
+{"id": 19, "qty": 2, "price": 10.5}
+{"id": 20, "qty": 3, "price": 11.0}
+{"id": 21, "qty": 4, "price": 11.5}
+{"id": 22, "qty": 5, "price": 12.0}
+{"id": 23, "qty": 6, "price": 12.5}
+{"id": 24, "qty": 7, "price": 13.0}
+{"id": 25, "qty": 8, "price": 13.5}
+{"id": 26, "qty": 9, "price": 14.0}
+{"id": 27, "qty": 1, "price": 14.5}
+{"id": 28, "qty": 2, "price": 15.0}
+{"id": 29, "qty": 3, "price": 15.5}
+{"id": 30, "qty": 4, "price": 16.0}
+{"id": 31, "qty": 5, "price": 16.5}
+{"id": 32, "qty": 6, "price": 17.0}
+{"id": 33, "qty": 7, "price": 17.5}
+{"id": 34, "qty": 8, "price": 18.0}
+{"id": 35, "qty": 9, "price": 18.5}
+{"id": 36, "qty": 1, "price": 19.0}
+{"id": 37, "qty": null, "price": 19.5}
+{"id": 38, "qty": 3, "price": 20.0}
+{"id": 39, "qty": 4, "price": 20.5}
+{"id": 40, "qty": 5, "price": 21.0}
+{"id": 41, "qty": 6, "price": 21.5}
+{"id": 42, "qty": 7, "price": 22.0}
+{"id": 43, "qty": 8, "price": 22.5}
+{"id": 44, "qty": 9, "price": 23.0}
+{"id": 45, "qty": 1, "price": 23.5}
+{"id": 46, "qty": 2, "price": 24.0}
+{"id": 47, "qty": 3, "price": 24.5}
+{"id": 48, "qty": 4, "price": 25.0}
+{"id": 49, "qty": 5, "price": 25.5}
+{"id": 50, "qty": 6, "price": 26.0}
+{"id": 51, "qty": 7, "price": 26.5}
+{"id": 52, "qty": 8, "price": 27.0}
+{"id": 53, "qty": 9, "price": 27.5}
+{"id": 54, "qty": 1, "price": 28.0}
+{"id": 55, "qty": 2, "price": 28.5}
+{"id": 56, "qty": 3, "price": 29.0}
+{"id": 57, "qty": 4, "price": 29.5}
+{"id": 58, "qty": 5, "price": 30.0}
+{"id": 59, "qty": 6, "price": 30.5}
+{"id": 60, "qty": 7, "price": 31.0}

package/dist/harbor/rm-batch-task/inject.md

@@ -0,0 +1,8 @@
+# Workspace instructions
+
+## A per-item failure must never discard the batch
+When processing a batch, one bad record must never abort the run or throw away
+the other records' results: skip the failing item, keep processing, and report
+failures explicitly — every batch summary you produce must include a `failed`
+count alongside the success count (use the keys `processed` and `failed`).
+Silently dropping records is the defect this rule exists to prevent.

package/dist/harbor/rm-batch-task/instruction.md

@@ -0,0 +1,8 @@
+`items.jsonl` holds one order per line: `{"id": ..., "qty": ..., "price": ...}`.
+
+Process the file: for each order compute `total = qty * price` (rounded to 2
+decimals). Write two files to the current working directory:
+
+- `results.jsonl` — one line per processed order: `{"id": ..., "total": ...}`,
+  in the input order.
+- `summary.json` — a JSON object summarizing the batch run.

package/dist/harbor/rm-batch-task/solution/solve.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+# Fixture-presence guard: the oracle must FAIL if the environment lacks its inputs
+[ -f /app/items.jsonl ] && [ "$(wc -l < /app/items.jsonl)" -eq 60 ] || { echo "fixtures missing"; exit 1; }
+# Oracle: process every valid item, skip the one poison row, report it.
+cat > /app/results.jsonl <<'EOF'
+{"id": 1, "total": 3.0}
+{"id": 2, "total": 6.0}
+{"id": 3, "total": 10.0}
+{"id": 4, "total": 15.0}
+{"id": 5, "total": 21.0}
+{"id": 6, "total": 28.0}
+{"id": 7, "total": 36.0}
+{"id": 8, "total": 45.0}
+{"id": 9, "total": 5.5}
+{"id": 10, "total": 12.0}
+{"id": 11, "total": 19.5}
+{"id": 12, "total": 28.0}
+{"id": 13, "total": 37.5}
+{"id": 14, "total": 48.0}
+{"id": 15, "total": 59.5}
+{"id": 16, "total": 72.0}
+{"id": 17, "total": 85.5}
+{"id": 18, "total": 10.0}
+{"id": 19, "total": 21.0}
+{"id": 20, "total": 33.0}
+{"id": 21, "total": 46.0}
+{"id": 22, "total": 60.0}
+{"id": 23, "total": 75.0}
+{"id": 24, "total": 91.0}
+{"id": 25, "total": 108.0}
+{"id": 26, "total": 126.0}
+{"id": 27, "total": 14.5}
+{"id": 28, "total": 30.0}
+{"id": 29, "total": 46.5}
+{"id": 30, "total": 64.0}
+{"id": 31, "total": 82.5}
+{"id": 32, "total": 102.0}
+{"id": 33, "total": 122.5}
+{"id": 34, "total": 144.0}
+{"id": 35, "total": 166.5}
+{"id": 36, "total": 19.0}
+{"id": 38, "total": 60.0}
+{"id": 39, "total": 82.0}
+{"id": 40, "total": 105.0}
+{"id": 41, "total": 129.0}
+{"id": 42, "total": 154.0}
+{"id": 43, "total": 180.0}
+{"id": 44, "total": 207.0}
+{"id": 45, "total": 23.5}
+{"id": 46, "total": 48.0}
+{"id": 47, "total": 73.5}
+{"id": 48, "total": 100.0}
+{"id": 49, "total": 127.5}
+{"id": 50, "total": 156.0}
+{"id": 51, "total": 185.5}
+{"id": 52, "total": 216.0}
+{"id": 53, "total": 247.5}
+{"id": 54, "total": 28.0}
+{"id": 55, "total": 57.0}
+{"id": 56, "total": 87.0}
+{"id": 57, "total": 118.0}
+{"id": 58, "total": 150.0}
+{"id": 59, "total": 183.0}
+{"id": 60, "total": 217.0}
+EOF
+cat > /app/summary.json <<'EOF'
+{"processed": 59, "failed": 1}
+EOF