r2s 0.2.1__py3-none-any.whl

r2s/__init__.py

@@ -0,0 +1,22 @@
+"""r2s — reference runtime for the research-to-ship schema contract."""
+
+from r2s.errors import KillError, ScoreError, ValidationError
+from r2s.handoff import handoff
+from r2s.io import load_board, load_card, load_json
+from r2s.rank import rank
+from r2s.score import score, should_kill
+
+__all__ = [
+    "KillError",
+    "ScoreError",
+    "ValidationError",
+    "handoff",
+    "load_board",
+    "load_card",
+    "load_json",
+    "rank",
+    "score",
+    "should_kill",
+]
+
+__version__ = "0.2.1"

r2s/cli.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from r2s.handoff import handoff
+from r2s.io import load_board, load_card
+from r2s.rank import rank
+from r2s.score import score, should_kill
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="r2s", description="r2s reference runtime CLI")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    p_rank = sub.add_parser("rank", help="Rank cards on a board")
+    p_rank.add_argument("board", help="Path to board JSON")
+
+    p_score = sub.add_parser("score", help="Score a single card")
+    p_score.add_argument("card", help="Path to card JSON")
+
+    p_hand = sub.add_parser("handoff", help="Emit handoff JSON for a card")
+    p_hand.add_argument("card", help="Path to card JSON")
+    p_hand.add_argument("--draft", help="Optional draft JSON with handoff fields")
+
+    args = parser.parse_args(argv)
+
+    if args.cmd == "rank":
+        board = load_board(args.board)
+        ranked = rank(board)
+        out = []
+        for card in ranked:
+            killed, reason = should_kill(card)
+            item = {"id": card["id"], "score": score(card), "status": card["status"]}
+            if killed:
+                item["kill_reason"] = reason
+            out.append(item)
+        json.dump(out, sys.stdout, indent=2)
+        sys.stdout.write("\n")
+        return 0
+
+    if args.cmd == "score":
+        card = load_card(args.card)
+        killed, reason = should_kill(card)
+        payload = {"id": card["id"], "score": score(card), "killed": killed, "kill_reason": reason}
+        json.dump(payload, sys.stdout, indent=2)
+        sys.stdout.write("\n")
+        return 0
+
+    if args.cmd == "handoff":
+        card = load_card(args.card)
+        draft = None
+        if args.draft:
+            draft = json.loads(open(args.draft, encoding="utf-8").read())
+        packet = handoff(card, draft=draft)
+        json.dump(packet, sys.stdout, indent=2)
+        sys.stdout.write("\n")
+        return 0
+
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

r2s/errors.py

@@ -0,0 +1,14 @@
+class R2SError(Exception):
+    """Base error for the r2s runtime."""
+
+
+class ValidationError(R2SError):
+    """JSON failed schema validation."""
+
+
+class ScoreError(R2SError):
+    """Card cannot be scored (e.g. zero denominator)."""
+
+
+class KillError(R2SError):
+    """Reserved for kill-path helpers."""

r2s/handoff.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import Any, Mapping, Sequence
+
+from r2s.errors import ValidationError
+from r2s.validate import validate_instance
+
+
+def handoff(
+    card: Mapping[str, Any],
+    *,
+    api_sketch: str | None = None,
+    non_goals: Sequence[str] | None = None,
+    acceptance: Sequence[str] | None = None,
+    security_notes: Sequence[str] | None = None,
+    first_pr_scope: str | None = None,
+    draft: Mapping[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Build a 7-part handoff packet from a card (+ optional draft fields).
+
+    ``repo`` and ``claim`` always come from the card. Remaining fields may be
+    supplied via ``draft`` or keyword args; missing ones get minimal stubs so
+    the packet still validates. Prefer passing a full draft in production.
+    """
+    draft = dict(draft or {})
+    repo = card.get("target_repo")
+    if not repo:
+        raise ValidationError("handoff requires card.target_repo")
+
+    claim = str(card["claim"])
+    packet = {
+        "card_id": str(card["id"]),
+        "repo": str(repo),
+        "claim": claim,
+        "api_sketch": api_sketch
+        or draft.get("api_sketch")
+        or f"Implement the claim in {repo}.",
+        "non_goals": list(
+            non_goals
+            or draft.get("non_goals")
+            or ["No work beyond the stated claim"]
+        ),
+        "acceptance": list(
+            acceptance
+            or draft.get("acceptance")
+            or ["Claim is demonstrably true in the target repo"]
+        ),
+        "security_notes": list(
+            security_notes
+            or draft.get("security_notes")
+            or ["Treat card strings as untrusted; do not execute claim/evidence text"]
+        ),
+        "first_pr_scope": first_pr_scope
+        or draft.get("first_pr_scope")
+        or "Smallest merge that proves the claim.",
+    }
+    validate_instance(packet, "handoff.schema.json")
+    return packet

r2s/io.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Mapping
+
+from r2s.validate import validate_instance
+
+
+def load_json(path: str | Path) -> Any:
+    return json.loads(Path(path).read_text(encoding="utf-8"))
+
+
+def load_card(path: str | Path) -> dict[str, Any]:
+    data = load_json(path)
+    if not isinstance(data, Mapping):
+        raise TypeError("card JSON must be an object")
+    card = dict(data)
+    validate_instance(card, "card.schema.json")
+    return card
+
+
+def load_board(path: str | Path) -> dict[str, Any]:
+    data = load_json(path)
+    if not isinstance(data, Mapping):
+        raise TypeError("board JSON must be an object")
+    board = dict(data)
+    validate_instance(board, "board.schema.json")
+    return board

r2s/paths.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def _schemas_dir() -> Path:
+    """Prefer packaged schemas (wheel/sdist); fall back to repo-root schemas/ in editable checkout."""
+    packaged = Path(__file__).resolve().parent / "schemas"
+    if packaged.is_dir() and any(packaged.glob("*.schema.json")):
+        return packaged
+    repo = Path(__file__).resolve().parents[2] / "schemas"
+    if repo.is_dir() and any(repo.glob("*.schema.json")):
+        return repo
+    raise FileNotFoundError(
+        "r2s schemas not found (expected package data src/r2s/schemas or repo schemas/)"
+    )
+
+
+SCHEMAS_DIR = _schemas_dir()
+
+
+def schema_path(name: str) -> Path:
+    return SCHEMAS_DIR / name

r2s/rank.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from r2s.score import score, should_kill
+
+
+def rank(board: Mapping[str, Any]) -> list[dict[str, Any]]:
+    """Rank cards by descending S, tie-break ascending id.
+
+    Cards that fail kill rules or are unscorable are omitted from the ranked
+    list. Among remaining cards, at most ``max_active_builds`` cards with
+    status ``build`` are kept (highest S first); other statuses are uncapped
+    except by overall sort order for presentation.
+    """
+    max_builds = int(board.get("max_active_builds") or 2)
+    cards = [dict(c) for c in board.get("cards", [])]
+
+    scored: list[tuple[float, str, dict[str, Any]]] = []
+    for card in cards:
+        killed, _ = should_kill(card)
+        if killed:
+            continue
+        try:
+            s = score(card)
+        except Exception:
+            continue
+        scored.append((s, str(card["id"]), card))
+
+    scored.sort(key=lambda t: (-t[0], t[1]))
+
+    result: list[dict[str, Any]] = []
+    builds = 0
+    for s, _id, card in scored:
+        if card.get("status") == "build":
+            if builds >= max_builds:
+                continue
+            builds += 1
+        result.append(card)
+    return result

r2s/schemas/board.schema.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ao3575911.github.io/r2s/schemas/board.schema.json",
+  "title": "R2S Board",
+  "description": "Hypothesis board: a set of cards plus ranking policy.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "version",
+    "cards"
+  ],
+  "properties": {
+    "version": {
+      "type": "string",
+      "const": "0.1.0"
+    },
+    "max_active_builds": {
+      "type": "integer",
+      "minimum": 1,
+      "default": 2
+    },
+    "cards": {
+      "type": "array",
+      "items": {
+        "$ref": "card.schema.json"
+      }
+    }
+  }
+}

r2s/schemas/card.schema.json

@@ -0,0 +1,174 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ao3575911.github.io/r2s/schemas/card.schema.json",
+  "title": "R2S Card",
+  "description": "Normalized research signal for the research-to-ship loop.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "id",
+    "claim",
+    "evidence",
+    "novelty",
+    "evidence_strength",
+    "usability",
+    "dependency_fit",
+    "hours",
+    "compute_cost",
+    "blast_radius",
+    "status"
+  ],
+  "properties": {
+    "id": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Stable card id (slug)."
+    },
+    "claim": {
+      "type": "string",
+      "minLength": 1,
+      "description": "One sentence the eventual code must make true."
+    },
+    "evidence": {
+      "type": "array",
+      "minItems": 0,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "kind",
+          "ref"
+        ],
+        "properties": {
+          "kind": {
+            "type": "string",
+            "enum": [
+              "paper",
+              "repo",
+              "doc",
+              "spike",
+              "outcome",
+              "other"
+            ]
+          },
+          "ref": {
+            "type": "string",
+            "minLength": 1
+          },
+          "note": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "earn_path": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "who_pays": {
+          "type": "string"
+        },
+        "wedge": {
+          "type": "string"
+        },
+        "cheapest_test": {
+          "type": "string"
+        }
+      }
+    },
+    "target_repo": {
+      "type": "string",
+      "pattern": "^[^/\\s]+/[^/\\s]+$",
+      "description": "owner/name when status is design or later."
+    },
+    "novelty": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 1
+    },
+    "evidence_strength": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 1
+    },
+    "usability": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 1
+    },
+    "dependency_fit": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 1
+    },
+    "hours": {
+      "type": "number",
+      "exclusiveMinimum": 0
+    },
+    "compute_cost": {
+      "type": "number",
+      "minimum": 0
+    },
+    "blast_radius": {
+      "type": "number",
+      "minimum": 0
+    },
+    "status": {
+      "type": "string",
+      "enum": [
+        "sense",
+        "design",
+        "build",
+        "ship",
+        "learn",
+        "killed"
+      ]
+    },
+    "kill_reason": {
+      "type": "string"
+    },
+    "notes": {
+      "type": "string"
+    }
+  },
+  "allOf": [
+    {
+      "if": {
+        "properties": {
+          "status": {
+            "enum": [
+              "design",
+              "build",
+              "ship"
+            ]
+          }
+        },
+        "required": [
+          "status"
+        ]
+      },
+      "then": {
+        "required": [
+          "target_repo"
+        ]
+      }
+    },
+    {
+      "if": {
+        "properties": {
+          "status": {
+            "const": "killed"
+          }
+        },
+        "required": [
+          "status"
+        ]
+      },
+      "then": {
+        "required": [
+          "kill_reason"
+        ]
+      }
+    }
+  ]
+}

r2s/schemas/handoff.schema.json

@@ -0,0 +1,60 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ao3575911.github.io/r2s/schemas/handoff.schema.json",
+  "title": "R2S Handoff Packet",
+  "description": "Fixed 7-part ship handoff for Builder (or any implementer).",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "repo",
+    "claim",
+    "api_sketch",
+    "non_goals",
+    "acceptance",
+    "security_notes",
+    "first_pr_scope"
+  ],
+  "properties": {
+    "card_id": {
+      "type": "string"
+    },
+    "repo": {
+      "type": "string",
+      "pattern": "^[^/\\s]+/[^/\\s]+$"
+    },
+    "claim": {
+      "type": "string",
+      "minLength": 1
+    },
+    "api_sketch": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Public surface the outside world sees (for a spec repo: schemas and docs paths)."
+    },
+    "non_goals": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "minItems": 1
+    },
+    "acceptance": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "minItems": 1
+    },
+    "security_notes": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "minItems": 1
+    },
+    "first_pr_scope": {
+      "type": "string",
+      "minLength": 1
+    }
+  }
+}

r2s/schemas/outcome.schema.json

@@ -0,0 +1,82 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ao3575911.github.io/r2s/schemas/outcome.schema.json",
+  "title": "R2S Outcome",
+  "description": "Closed-loop result used to update ranking judgment (human-applied in v0).",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "card_id",
+    "result",
+    "recorded_at"
+  ],
+  "properties": {
+    "card_id": {
+      "type": "string",
+      "minLength": 1
+    },
+    "result": {
+      "type": "string",
+      "enum": [
+        "ship",
+        "kill",
+        "learn"
+      ]
+    },
+    "recorded_at": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "time_to_green_hours": {
+      "type": "number",
+      "minimum": 0
+    },
+    "second_consumer": {
+      "type": "boolean",
+      "description": "Did a second module/repo consume the API?"
+    },
+    "earn_hypothesis_held": {
+      "type": "boolean"
+    },
+    "notes": {
+      "type": "string"
+    },
+    "kill_reason": {
+      "type": "string"
+    },
+    "commit_sha": {
+      "type": "string",
+      "pattern": "^[0-9a-f]{40}$",
+      "description": "Git commit SHA that realizes this outcome (usually the merge or tip commit)."
+    },
+    "merge_commit_sha": {
+      "type": "string",
+      "pattern": "^[0-9a-f]{40}$",
+      "description": "Merge commit SHA when the ship landed via PR."
+    },
+    "pr": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "Pull request number when applicable."
+    }
+  },
+  "allOf": [
+    {
+      "if": {
+        "properties": {
+          "result": {
+            "const": "kill"
+          }
+        },
+        "required": [
+          "result"
+        ]
+      },
+      "then": {
+        "required": [
+          "kill_reason"
+        ]
+      }
+    }
+  ]
+}

r2s/schemas/scoring.schema.json

@@ -0,0 +1,52 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ao3575911.github.io/r2s/schemas/scoring.schema.json",
+  "title": "R2S Scoring Rules",
+  "description": "Normative scoring and kill rules for implementers.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "formula",
+    "kill_rules",
+    "rank_policy"
+  ],
+  "properties": {
+    "formula": {
+      "type": "string",
+      "const": "S = (novelty * evidence_strength * usability * dependency_fit) / (hours + compute_cost + blast_radius)"
+    },
+    "denominator_guard": {
+      "type": "string",
+      "description": "If hours + compute_cost + blast_radius == 0, treat as invalid card (do not score)."
+    },
+    "kill_rules": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "minItems": 1
+    },
+    "rank_policy": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "order",
+        "tie_break"
+      ],
+      "properties": {
+        "order": {
+          "type": "string",
+          "const": "descending_S"
+        },
+        "tie_break": {
+          "type": "string",
+          "const": "ascending_id"
+        },
+        "max_active_builds": {
+          "type": "integer",
+          "minimum": 1
+        }
+      }
+    }
+  }
+}

r2s/score.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from r2s.errors import ScoreError
+
+# Kill threshold: "near 0" in SPEC — treat values <= epsilon as near zero.
+_NEAR_ZERO = 1e-9
+_DESIGN_PLUS = frozenset({"design", "build", "ship"})
+
+
+def score(card: Mapping[str, Any]) -> float:
+    """Return S = (N*E*U*D) / (H+C+B). Raises ScoreError if denominator is 0."""
+    n = float(card["novelty"])
+    e = float(card["evidence_strength"])
+    u = float(card["usability"])
+    d = float(card["dependency_fit"])
+    h = float(card["hours"])
+    c = float(card["compute_cost"])
+    b = float(card["blast_radius"])
+    denom = h + c + b
+    if denom == 0:
+        raise ScoreError("hours + compute_cost + blast_radius == 0; card is unscorable")
+    return (n * e * u * d) / denom
+
+
+def should_kill(card: Mapping[str, Any]) -> tuple[bool, str | None]:
+    """Apply SPEC kill rules. Returns (killed?, reason)."""
+    if float(card["usability"]) <= _NEAR_ZERO:
+        return True, "usability near 0"
+    if float(card["dependency_fit"]) <= _NEAR_ZERO:
+        return True, "dependency_fit near 0"
+    status = card["status"]
+    if status in _DESIGN_PLUS and not card.get("target_repo"):
+        return True, "missing target_repo at design+"
+    return False, None

r2s/validate.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import json
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, Mapping
+
+from jsonschema import Draft202012Validator
+from referencing import Registry, Resource
+
+from r2s.errors import ValidationError
+from r2s.paths import SCHEMAS_DIR
+
+
+@lru_cache(maxsize=1)
+def _registry() -> Registry:
+    registry: Registry = Registry()
+    for path in sorted(SCHEMAS_DIR.glob("*.schema.json")):
+        data = json.loads(path.read_text(encoding="utf-8"))
+        resource = Resource.from_contents(data)
+        registry = registry.with_resource(str(data["$id"]), resource)
+        registry = registry.with_resource(path.name, resource)
+    return registry
+
+
+def validate_instance(instance: Mapping[str, Any], schema_filename: str) -> None:
+    schema_file = SCHEMAS_DIR / schema_filename
+    if not schema_file.is_file():
+        raise ValidationError(f"missing schema: {schema_filename}")
+    schema = json.loads(schema_file.read_text(encoding="utf-8"))
+    validator = Draft202012Validator(schema, registry=_registry())
+    errors = sorted(validator.iter_errors(instance), key=lambda e: list(e.path))
+    if errors:
+        first = errors[0]
+        path = "/".join(str(p) for p in first.path) or "(root)"
+        raise ValidationError(f"{schema_filename} @ {path}: {first.message}")

r2s-0.2.1.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: r2s
+Version: 0.2.1
+Summary: Reference runtime for the r2s research-to-ship JSON Schema contract
+Author: ao3575911
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ao3575911/r2s
+Project-URL: Repository, https://github.com/ao3575911/r2s
+Project-URL: Changelog, https://github.com/ao3575911/r2s/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/ao3575911/r2s/issues
+Project-URL: Documentation, https://github.com/ao3575911/r2s/blob/main/docs/SPEC.md
+Keywords: json-schema,research,handoff,ranking,specification
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jsonschema<5,>=4.22
+Requires-Dist: referencing<1,>=0.35
+Provides-Extra: dev
+Requires-Dist: pytest<9,>=8; extra == "dev"
+Requires-Dist: build<2,>=1.2; extra == "dev"
+Requires-Dist: twine<7,>=5; extra == "dev"
+Dynamic: license-file
+
+<p align="center">
+  <img src="docs/brand/icon.png" alt="r2s" width="96" height="96" />
+</p>
+
+<h1 align="center">r2s</h1>
+
+<p align="center">
+  <strong>↻ research → rank → ship</strong><br />
+  JSON Schema contract for turning research signals into repo and library work.
+</p>
+
+<p align="center">
+  <img src="docs/brand/loop.gif" alt="sense → rank → handoff → ship" width="640" />
+</p>
+
+<p align="center">
+  <a href="docs/SPEC.md"><img src="https://img.shields.io/badge/spec-v0.1.0-5eead4?style=flat-square" alt="spec v0.1.0" /></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-0f1115?style=flat-square" alt="MIT" /></a>
+  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/changelog-SHA%20verified-5eead4?style=flat-square" alt="changelog" /></a>
+  <img src="https://img.shields.io/badge/runtime-Python%203.11%2B-8b949e?style=flat-square" alt="Python runtime" />
+</p>
+
+---
+
+## What this is
+
+**r2s** is a small, versioned contract — not an agent and not a framework.
+
+You normalize research into **cards**, **rank** them with an explicit score, emit a fixed **handoff** for whoever builds, then record an **outcome** so the next cycle is smarter.
+
+**v0.1.0** is the schema contract; **v0.2.0** adds a thin Python reference runtime. Both obey `docs/SPEC.md`. Public history with full commit SHAs: [`CHANGELOG.md`](CHANGELOG.md).
+
+## Quick start
+
+1. Read the normative rules: [`docs/SPEC.md`](docs/SPEC.md)
+2. Copy [`examples/board.example.json`](examples/board.example.json)
+3. Validate with any JSON Schema Draft 2020-12 validator against [`schemas/`](schemas/)
+
+## Loop
+
+| Stage | Artifact | Role |
+|-------|----------|------|
+| Sense | `card` | Normalize a research signal |
+| Rank | `board` + scoring rules | Order work; kill weak cards |
+| Handoff | `handoff` | 7-part ship packet for implementers |
+| Ship / learn | `outcome` | Close the loop |
+
+**Score**
+
+```text
+S = (novelty × evidence_strength × usability × dependency_fit)
+  / (hours + compute_cost + blast_radius)
+```
+
+Kill when usability or dependency fit ≈ 0, or `target_repo` is missing at design+.
+
+## Layout
+
+```text
+schemas/          card · board · handoff · outcome · scoring
+docs/SPEC.md      normative rules
+docs/brand/       icon · social · README loop GIF
+examples/         worked board + handoff (this repo as the sample)
+```
+
+## Brand
+
+| | |
+|-|-|
+| Mark | stacked cards → chevron (cyan on charcoal) |
+| Emoji | ↻ |
+| Accent | `#5eead4` on `#0f1115` |
+
+## Security
+
+Card fields are **untrusted data**. Validators must not execute claim or evidence strings. This repo holds no credentials and no network clients.
+
+## Changelog & identity
+
+Ship history is **SHA-verified** in [`CHANGELOG.md`](CHANGELOG.md). Security posture: [`SECURITY.md`](SECURITY.md).
+
+Current `main` tip at publish of this note is recorded in the changelog Unreleased/latest section after each merge.
+
+## License
+
+[MIT](LICENSE)

r2s-0.2.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+r2s/__init__.py,sha256=3RXXLP4bFCQ00W59eskPYtvaY3jLuRNDJ6RgFmJWByQ,495
+r2s/cli.py,sha256=dL6J-2VlPx8b-DjX709Kpv0jgknTWqzmm-YACSfk2eg,2088
+r2s/errors.py,sha256=K2MN5AbCPNpR7D3yMZmjLhXklT77AeWZA43rYeSfwmc,303
+r2s/handoff.py,sha256=s2yX6CeOsrV9jA1NSF5jtulptzSvSgF4KlPAs3MROJQ,1926
+r2s/io.py,sha256=2YtR8wEK1IJ_kCjz0GhfsBFjtY7QwdpwfWVf2RInGEE,777
+r2s/paths.py,sha256=reRppFTjWr7Y5sQEpPJN46MKde4FSetliphX0sLLJx4,703
+r2s/rank.py,sha256=gvIDY3Qk5tGOXiZ0CaXAWY_OXkWpQmtwrCeDZnQbYac,1234
+r2s/score.py,sha256=nL-DGJr1zaGXpDLPRASp-bB8REw1fobO4WqqQrjd_4U,1273
+r2s/validate.py,sha256=VewpVBJXuG3lolQwL5vK_MSIvn9pAWHlDNFiRvf-zkY,1338
+r2s/schemas/board.schema.json,sha256=iyFaxu6_FRE-pqgA4UAr8fztxVe4qggBzLay_CDBHy8,629
+r2s/schemas/card.schema.json,sha256=aKjhNSmewhcoEN9lxtlgHVemJ5yQRkPD8VufvF1N36o,3341
+r2s/schemas/handoff.schema.json,sha256=aZYMu4bOXtMlcVjg-dCeYkCU_kEZBpNpVatuw59Oi5g,1283
+r2s/schemas/outcome.schema.json,sha256=X2rnK7Vkp1cLU-uikiwO8ruSZsm8slaxiQJvFs31EWg,1777
+r2s/schemas/scoring.schema.json,sha256=LkN1otuMILbkf1mUNrxGDhiz5o63P23PL_9Qb96PsWA,1305
+r2s-0.2.1.dist-info/licenses/LICENSE,sha256=-HiXdRZIQBhQbwFgC-rY5_tZ_2ej1kQI58ZN2vLK6xk,1082
+r2s-0.2.1.dist-info/METADATA,sha256=ZWCQPxo0OXpQ-Mf56ZWxufXiFM44jsJwgUlPpVKeVdA,4208
+r2s-0.2.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+r2s-0.2.1.dist-info/entry_points.txt,sha256=qTXgt6vIHv-lA7nqNVv7mOYwRDsheqjiP6PVuaLvBXQ,37
+r2s-0.2.1.dist-info/top_level.txt,sha256=6ccEVxLvLdFZoJVGVXSdLoLCOLHmjJtbUK188Q9VUFA,4
+r2s-0.2.1.dist-info/RECORD,,

r2s-0.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

r2s-0.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+r2s = r2s.cli:main

r2s-0.2.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Adam O'Connor (ao3575911)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

r2s-0.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+r2s