rapier-runtime 0.6.2__tar.gz → 0.6.3__tar.gz

{rapier_runtime-0.6.2 → rapier_runtime-0.6.3}/CHANGELOG.md

@@ -4,6 +4,19 @@ Notable changes to `rapier-runtime`. Earlier releases are summarized in
 [`docs/STATUS.md`](docs/STATUS.md) and on the
 [Releases](https://github.com/muddyone/rapier-runtime/releases) page.
 
+## 0.6.3 — 2026-11-14
+
+### Fixed: an unreadable policy file is no longer reported as the minimum refusing the run
+
+When the operator policy file could not be read or checked (bad JSON, an
+unknown level, a non-boolean `require_independent`, a folder Rapier can't
+search), 0.6.2 stopped the run, correctly, but credited the stop to the
+operator minimum (`refused_by: "operator_minimum"`, `final_state: "refuse"`).
+The minimum was never read, so it decided nothing. The run still stops (MCP
+`ok: false`, CLI exit 2), now with `final_state: "defer"`, no `refused_by`, and
+`operator_policy: "did-not-run: <reason>"`. A readable policy that refuses a
+request is unchanged: `refuse`, credited to the control that decided.
+
 ## 0.6.2 — 2026-11-14
 
 ### Added: every run names its final state

{rapier_runtime-0.6.2 → rapier_runtime-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rapier-runtime
-Version: 0.6.2
+Version: 0.6.3
 Summary: A code-orchestrated engine that runs the SPARRING method: grounded, cross-vendor adversarial review for AI-in-the-loop decisions.
 Project-URL: Homepage, https://rapierruntime.com
 Project-URL: Repository, https://github.com/muddyone/rapier-runtime

{rapier_runtime-0.6.2 → rapier_runtime-0.6.3}/docs/STATUS.md

@@ -1,9 +1,26 @@
 # Rapier — dev status
 
-_Last updated: 2026-10-16 (tag v0.6.1, 264 tests)._ A running "where we are /
+_Last updated: 2026-11-14 (tag v0.6.2, 382 tests)._ A running "where we are /
 what's next" so a new session can continue without reconstructing from git log.
 
 ## Done
+- **RELEASED (2026-11-14) — `rapier-runtime` 0.6.2 on PyPI. The six Accountable
+  Agents changes** (from Thomas Gessler's two concept papers,
+  doi:10.5281/zenodo.20687710 and doi:10.5281/zenodo.21850919). Git tag `v0.6.2`
+  (1020a765); https://pypi.org/project/rapier-runtime/0.6.2/. Built by
+  rapier-runtime-2 and passed item by item by the rapier-runtime-1 verifier in
+  the first multi-project team test (D-61); Bart chose 0.6.2 (D-69). In short:
+  an operator minimum for the citation check that a caller can't lower
+  (`/etc/rapier/policy.json`, reported as out of reach only when Rapier neither
+  owns nor can write it), and `require_independent` there; every check reports
+  `ran` / `nothing-to-check` / `did-not-run: <reason>`, judged on its last run;
+  a WHAT RAN section and pre-run manifest checks (`rapier doctor --manifest`);
+  a final state in the papers' six names, with a labelled NON-DECISION (D-67 a);
+  and a method hash (declared and as-run, including vendor bindings and the
+  package code). Full list in `CHANGELOG.md`. Verified from PyPI: a clean
+  install reports 0.6.2 and `rapier doctor` shows the operator minimum and the
+  per-ceremony checks. Follow-up, not blocking: key the "gate before the answer"
+  rule on the pipeline's stage order rather than writers' own traces.
 - **RELEASED (2026-10-16) — `rapier-runtime` 0.6.1 on PyPI. The arithmetic
   check ("WHETHER THE NUMBERS ADD UP") stops flagging correct formulas.** Git
   tag `v0.6.1`; https://pypi.org/project/rapier-runtime/0.6.1/. Reported by

{rapier_runtime-0.6.2 → rapier_runtime-0.6.3}/docs/chatlogs/202611141130.inflight.accountable-agents-gaps.md

@@ -4,7 +4,7 @@
 **Project**: rapier-runtime
 **HEAD**: 9214c14b (chatlog: reconcile false alarms fixed, 0.6.1 released)
 **Captured by**: Bart (from a vitae session, vit-1)
-**Status**: open
+**Status**: closed (all six released in 0.6.2, 2026-11-14, tag v0.6.2 at 1020a765)
 
 ## Source
 

{rapier_runtime-0.6.2 → rapier_runtime-0.6.3}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rapier-runtime"
-version = "0.6.2"
+version = "0.6.3"
 description = "A code-orchestrated engine that runs the SPARRING method: grounded, cross-vendor adversarial review for AI-in-the-loop decisions."
 readme = "README.md"
 requires-python = ">=3.10"

{rapier_runtime-0.6.2 → rapier_runtime-0.6.3}/src/rapier/cli.py

@@ -377,7 +377,7 @@ def main(argv: list[str] | None = None) -> int:
         if err:  # no vendor keys — fail loudly, not silently
             print(err, file=sys.stderr)
             return 2
-        from .operator_policy import PolicyError, decide_independence, decide_verify
+        from .operator_policy import PolicyError, decide_independence, decide_verify, stop_message
 
         try:
             decision = decide_verify(
@@ -388,7 +388,7 @@ def main(argv: list[str] | None = None) -> int:
                 else "default",
             )
         except PolicyError as exc:
-            print(f"refused: {exc}", file=sys.stderr)
+            print(stop_message(exc), file=sys.stderr)
             return 2
         preset = load_preset(
             args.cmd, settle=getattr(args, "settle", 0), verify=decision.mode,
@@ -398,7 +398,7 @@ def main(argv: list[str] | None = None) -> int:
         try:
             decide_independence(getattr(preset, "policy", None))
         except PolicyError as exc:
-            print(f"refused: {exc}", file=sys.stderr)
+            print(stop_message(exc), file=sys.stderr)
             return 2
         # Carry context the pipeline can't observe onto the envelope for the
         # ceremony-ledger row: the resolver knobs, and the front-door Frame
@@ -422,7 +422,7 @@ def main(argv: list[str] | None = None) -> int:
                     report_all=getattr(args, "report_all", False), seed_meta=seed_meta,
                     no_save=getattr(args, "no_save", False))
     if args.cmd == "run":
-        from .operator_policy import PolicyError, decide_independence, decide_manifest
+        from .operator_policy import PolicyError, decide_independence, decide_manifest, stop_message
 
         manifest = Manifest.load(args.manifest)
         try:
@@ -431,7 +431,7 @@ def main(argv: list[str] | None = None) -> int:
                    for s in manifest.stages):
                 decide_independence(manifest.policy)
         except PolicyError as exc:
-            print(f"refused: {exc}", file=sys.stderr)
+            print(stop_message(exc), file=sys.stderr)
             return 2
         return _run(manifest, request, args.ledger_dir, seed_meta=decision.meta(),
                     no_save=getattr(args, "no_save", False))

{rapier_runtime-0.6.2 → rapier_runtime-0.6.3}/src/rapier/mcp/tools.py

@@ -69,21 +69,19 @@ def _run(
         return {"ok": False, "error": err}
     # The operator minimum is applied here, before anything runs. Its sources are
     # a fixed system file and the process environment; no tool argument reaches it.
-    from ..operator_policy import PolicyError, decide_independence, decide_verify
+    from ..operator_policy import PolicyError, decide_independence, decide_verify, stop_result
 
     set_by = ("fixed by the proposer tool" if name == "proposer"
               else "caller (MCP tool argument)")
     try:
         decision = decide_verify(verify, set_by)
     except PolicyError as exc:
-        return {"ok": False, "error": str(exc), "refused_by": "operator_minimum",
-                "final_state": "refuse"}
+        return stop_result(exc, "operator_minimum")
     preset = load_preset(name, settle=settle, verify=decision.mode, seed=seed, depth=depth)
     try:
         decide_independence(getattr(preset, "policy", None))
     except PolicyError as exc:
-        return {"ok": False, "error": str(exc), "refused_by": "operator_require_independent",
-                "final_state": "refuse"}
+        return stop_result(exc, "operator_require_independent")
     # Carry context the pipeline can't observe onto the envelope for the ceremony-ledger
     # row: the resolver knobs and the front-door Frame classification (a separate call).
     seed_meta: dict[str, Any] = {"settle": settle, **decision.meta()}

{rapier_runtime-0.6.2 → rapier_runtime-0.6.3}/src/rapier/operator_policy.py

@@ -59,8 +59,31 @@ POLICY_PATH = _default_policy_path()
 
 
 class PolicyError(Exception):
-    """The run is refused: a caller asked for less than the operator minimum,
-    or the operator's policy file is unreadable (fail closed)."""
+    """The run is refused: the operator's policy DECIDED against it (a caller
+    asked for less than the minimum, or no independent review is possible)."""
+
+
+class PolicyUnreadable(PolicyError):
+    """The run is stopped because the operator's policy could not be read or
+    checked (fail closed). The control did not run, so it decided nothing: the
+    stop holds, but it is never credited to the minimum, and the final state is
+    ``defer``, not ``refuse``. Subclasses PolicyError so a caller that only
+    wants "stopped or not" still catches both."""
+
+
+def stop_result(exc: PolicyError, refused_by: str) -> dict:
+    """The MCP result for a policy stop, attributing it only where a control decided."""
+    if isinstance(exc, PolicyUnreadable):
+        return {"ok": False, "error": str(exc), "final_state": "defer",
+                "operator_policy": f"did-not-run: {exc}"}
+    return {"ok": False, "error": str(exc), "refused_by": refused_by, "final_state": "refuse"}
+
+
+def stop_message(exc: PolicyError) -> str:
+    """The CLI's stderr line for a policy stop (exit code 2 either way)."""
+    if isinstance(exc, PolicyUnreadable):
+        return f"stopped (operator policy did not run, final state defer): {exc}"
+    return f"refused: {exc}"
 
 
 @dataclass(frozen=True)
@@ -87,7 +110,7 @@ class VerifyDecision:
 
 def _check_level(level, where: str) -> str:
     if level not in VERIFY_RANK:
-        raise PolicyError(f"operator policy {where}: unknown verify level {level!r}; "
+        raise PolicyUnreadable(f"operator policy {where}: unknown verify level {level!r}; "
                           f"known: {sorted(VERIFY_RANK)}")
     return level
 
@@ -136,19 +159,19 @@ def _read_policy_file() -> tuple[dict, str, bool] | None:
     except OSError as exc:
         # Can't tell whether a policy exists (e.g. its directory can't be searched).
         # An operator who locked the directory down meant a policy to apply: fail closed.
-        raise PolicyError(f"operator policy file {path} could not be checked ({exc}); "
+        raise PolicyUnreadable(f"operator policy file {path} could not be checked ({exc}); "
                           "refusing to run without the minimum it may set") from exc
     try:
         with open(path, encoding="utf-8") as fh:
             data = json.load(fh)
     except (OSError, ValueError) as exc:
-        raise PolicyError(f"operator policy file {path} could not be read ({exc}); "
+        raise PolicyUnreadable(f"operator policy file {path} could not be read ({exc}); "
                           "refusing to run without the minimum it sets") from exc
     if not isinstance(data, dict) or not any(k in data for k in _POLICY_KEYS):
-        raise PolicyError(f"operator policy file {path} sets none of {list(_POLICY_KEYS)}; "
+        raise PolicyUnreadable(f"operator policy file {path} sets none of {list(_POLICY_KEYS)}; "
                           "refusing to run without the minimum it was meant to set")
     if "require_independent" in data and not isinstance(data["require_independent"], bool):
-        raise PolicyError(f"operator policy file {path}: require_independent must be "
+        raise PolicyUnreadable(f"operator policy file {path}: require_independent must be "
                           "true or false; refusing to run")
     return data, path, _out_of_my_reach(path)
 

{rapier_runtime-0.6.2 → rapier_runtime-0.6.3}/tests/test_operator_minimum.py

@@ -212,7 +212,9 @@ def test_unsearchable_policy_dir_fails_closed(policy, mcp_stubbed):
         if os.access(path.parent, os.X_OK):
             pytest.skip("this filesystem ignores chmod")
         out = tools.run_spar("ship it?", verify="off")
-        assert out["ok"] is False and out["refused_by"] == "operator_minimum"
+        # R4-3: the minimum was never read, so the stop holds but is not credited to it
+        assert out["ok"] is False and out["final_state"] == "defer"
+        assert "refused_by" not in out and out["operator_policy"].startswith("did-not-run: ")
         assert "could not be checked" in out["error"]
         with pytest.raises(PolicyError):
             decide_verify("gate", "caller")  # can't know the floor: refuse every run
@@ -226,7 +228,9 @@ def test_bad_policy_file_fails_closed(policy, mcp_stubbed, body):
 
     pathlib.Path(OP.POLICY_PATH).write_text(body)
     out = tools.run_spar("ship it?", verify="gate")
-    assert out["ok"] is False and out["refused_by"] == "operator_minimum"
+    # R4-3: the minimum was never read, so the stop holds but is not credited to it
+    assert out["ok"] is False and out["final_state"] == "defer"
+    assert "refused_by" not in out and out["operator_policy"].startswith("did-not-run: ")
 
 
 # ── the report says who set the level, and whether the minimum is external ──
@@ -262,3 +266,41 @@ def test_report_says_an_in_reach_minimum_is_not_independent():
     env = _env(verify="gate", verify_set_by="default", verify_minimum="gate",
                verify_minimum_source="RAPIER_MIN_VERIFY", verify_minimum_external=False)
     assert "not an independent control" in " ".join(_render_report(env).split())
+
+
+# ── R4-3: a stop is credited to a control only when that control decided ────
+
+@pytest.mark.parametrize("body", ['{"min_verify":', '{"min_verify": "loud"}', "{}",
+                                  '{"require_independent": "yes"}'])
+def test_unreadable_policy_stops_as_defer_not_refuse(policy, mcp_stubbed, body):
+    import pathlib
+
+    pathlib.Path(OP.POLICY_PATH).write_text(body)
+    out = tools.run_spar("decide X", verify="gate")
+    assert out["ok"] is False
+    assert out["final_state"] == "defer"
+    assert "refused_by" not in out
+    assert out["operator_policy"].startswith("did-not-run: ")
+
+
+def test_control_readable_minimum_refuses_and_is_credited(policy, mcp_stubbed):
+    policy("gate")
+    out = tools.run_spar("decide X", verify="off")
+    assert out["final_state"] == "refuse" and out["refused_by"] == "operator_minimum"
+    assert "operator_policy" not in out
+
+
+def test_cli_unreadable_policy_says_defer(policy, monkeypatch, capsys):
+    import pathlib
+
+    from rapier import cli, onboarding
+
+    monkeypatch.setattr(onboarding, "preflight_error", lambda: None)
+    pathlib.Path(OP.POLICY_PATH).write_text('{"min_verify":')
+    assert cli.main(["spar", "--request", "x"]) == 2
+    err = capsys.readouterr().err
+    assert "operator policy did not run, final state defer" in err and "refused:" not in err
+
+
+def test_unreadable_policy_is_a_policy_error_subclass():
+    assert issubclass(OP.PolicyUnreadable, OP.PolicyError)