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

rapier_runtime-0.6.2/CHANGELOG.md

@@ -0,0 +1,208 @@
+# Changelog
+
+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.2 — 2026-11-14
+
+### Added: every run names its final state
+
+The report's BOTTOM LINE opens with a final state, using the six names from the
+Accountable Agents paper, and the same value is in the trust rider, `ceremony.json`
+(`final_state`, `final_state_next`) and the MCP result:
+
+- `act`: the advice cleared the checks that ran, and the report names them and any
+  that were switched off. Rapier only advises; acting on it is yours.
+- `block`: a specific failed the correctness check, or a reference was refuted.
+- `defer`: a declared check or the challenge review did not run on the answer
+  (crashed, no key, a reviewer error, or ran before the answer was written), or
+  the operator requires an independent review and none happened. A control that
+  did not run decided nothing, so this is never `block` and never `act`.
+- `escalate`: a specific reads ambiguously between fact and estimate; your call.
+- `non-decision`: the Proposer hit its round cap without agreeing on one option.
+  The report says so at the top, and in the Proposer report. The Resolver still
+  tests the strongest candidate, but choosing between the options is yours.
+- `refuse`: the run was refused before it started (operator minimum or
+  independence requirement).
+
+A citation check that was switched off or never declared doesn't change the
+state, but `act` says it didn't run. A review that failed at run time (the
+reviewer is fail-soft) is reported as not run, never as an independent challenge.
+
+### Added: the operator can require an independent review
+
+`"require_independent": true` in the operator policy file refuses any review
+ceremony (spar, sparring, proposer, or a custom manifest with a review or
+Proposer stage) when no second vendor is available. Without it, a single-vendor
+run goes ahead and the report says the review was not independent, as before.
+Only the operator can set this: there is no tool argument or environment
+variable for it. The refusal names the policy file and whether it is out of the
+caller's reach (MCP: `refused_by: "operator_require_independent"`; CLI: exit 2).
+`rapier doctor` shows the setting and warns when only one vendor is configured.
+
+### Added: a hash of the method that ran
+
+`ceremony.json` gains `method_hash` and `method_resolved_hash` (plus
+`rapier_version`), and THE RECORD shows both, shortened. `method_hash` covers
+the Rapier version, every stage in order with its config and roles, and the
+vendor policy. `method_resolved_hash` is the same after vendor substitution, so
+a run on different keys shows up as the same method on different vendors. To
+check for drift, compare runs on the same inputs under the same `method_hash`.
+
+### Added: what the method declared, compared with what ran
+
+- **WHAT RAN**, a new report section, lists every stage the method declared
+  and what happened to it: ran, FAILED (the run went on without it), skipped
+  (with the stage's reason) or not reached (cancelled). The pipeline records
+  this itself, so a stage that writes no trace still appears. Also in the trust
+  rider (`stages_run`) and `ceremony.json` (`stages_declared`,
+  `stages_failed_soft`, `stages_skipped`).
+- **Checked before a run.** A pipeline that writes a report but declares no
+  correctness gate, or puts a gate after `compose` where its result can't reach
+  the report, gets a warning in the log, the report and `ceremony.json`
+  (`manifest_warnings`). `rapier doctor` checks every built-in ceremony and
+  shows the operator minimum. `rapier doctor --manifest m.yaml` checks a custom
+  manifest and exits 1 if it warns or would be refused.
+- **Custom manifests meet the operator minimum.** `rapier run --manifest` with
+  no citation gate before `compose` counts as `verify=off` and is refused under
+  a `gate` minimum.
+
+### Added: an operator minimum for the checks, which the caller cannot lower
+
+Over MCP the agent whose answer is being checked chose `verify`, so it could
+switch the citation check off. The operator can now set a floor:
+
+- **`/etc/rapier/policy.json`** (`%PROGRAMDATA%\rapier\policy.json` on
+  Windows), `{"min_verify": "gate"}`. The path is fixed, not taken from the
+  environment, so a caller cannot point Rapier at a different file. The report
+  calls the minimum out of the calling agent's reach only when Rapier is not
+  running as root and neither owns nor can write the file or any folder above
+  it (for example, owned by root, readable by the user that runs Rapier). A
+  file that can't be checked, read or parsed fails closed.
+- **`RAPIER_MIN_VERIFY`** also sets a floor, but whoever launches the process
+  controls its environment, so the report always calls it within the caller's
+  reach.
+- A request below the floor is **refused**, with an error naming the floor and
+  its source (MCP: `ok: false`, `refused_by: "operator_minimum"`; CLI: exit 2).
+  A policy file that can't be read fails closed. Levels: `off` < `gate` ≤
+  `round`.
+- **The report says who set the level:** "switched off, by caller (MCP tool
+  argument)", the default or the `--verify` flag, and whether an operator
+  minimum stood behind it. `ceremony.json` gains `verify_set_by`,
+  `verify_minimum`, `verify_minimum_source` and `verify_minimum_external`.
+
+### Fixed: a check that did not run no longer reads like one that found nothing
+
+The report used one sentence for "the correctness check found no specifics" and
+"the checker was unavailable". With `verify=off` the registry section said the
+answer "cited nothing externally checkable", though nothing had been looked up.
+
+- **Three outcomes, kept apart**, for both the correctness check and the
+  citation check: `ran`, `nothing-to-check`, and `did-not-run: <reason>`. A
+  crash (caught fail-soft), a missing key, `verify=off`, and a check left out of
+  the pipeline are all `did-not-run`, and the report says it is not a pass.
+- **A run with no hard specifics** now says the check found nothing to check,
+  instead of "every hard specific it states traces to a fact you gave".
+- **Recorded everywhere the reader or a tool looks:** the report, the trust
+  rider (`correctness_check`, `citation_check`), `ceremony.json`
+  (`*_check` and `*_check_reason`) and the MCP result.
+
+## 0.6.1 — 2026-10-16
+
+### Fixed: "WHETHER THE NUMBERS ADD UP" no longer flags correct formulas
+
+The arithmetic check summed the numbers in any stated result, so a correct
+standard error, interval, sample size or difference was reported as wrong. In
+a statistics-heavy answer that was five false alarms out of five.
+
+- **Formulas are worked out as written.** Roots, powers, quotients and ±
+  bounds are evaluated in code, and a mismatch shows the formula it evaluated.
+  Differences are checked as differences.
+- **"Not checked" instead of a guess.** Where the operation can't be recovered
+  from the text, or a "total" turns out to be a formula, the figure is counted
+  as not checked, never as a mismatch. The section says how many there were.
+- **Small figures are checked properly.** The agreement margin used to be
+  measured against 1, so any figure under 1 agreed with almost anything. It is
+  now 0.5% of the figures themselves, or half a unit of the last digit the
+  text shows (`0.120` allows ±0.0005; `6×10⁻⁵` allows ±5×10⁻⁶).
+
+## 0.6.0 — 2026-10-16
+
+### Changed: the MCP server now runs on the mcp 2.x SDK
+
+The `[mcp]` extra now requires `mcp>=2.3,<3` (it was `>=1.2,<2`), and the
+server is built on the SDK's `MCPServer`. Tools, their results and the run
+resources behave as before. Two visible differences:
+
+- **Progress shows the stage.** Each stage's progress update now carries the
+  stage name as its message. mcp 2.x sends log messages only to clients that
+  ask for them, so the progress message is what every client will show.
+- **`pip install -U "rapier-runtime[mcp]"` upgrades the SDK.** An environment
+  pinned to mcp 1.x will be moved to 2.x. If a 1.x SDK is installed anyway,
+  `rapier mcp` says so and gives the command that fixes it.
+
+## 0.5.3 — 2026-10-16
+
+### Added: saved runs as MCP resources
+
+MCP clients can now browse saved runs instead of calling tools:
+
+- `rapier://runs`: every saved run, newest first, with its kind, topic and
+  verdict (JSON).
+- `rapier://runs/{run_id}`: a run's report, as the CLI printed it (plain text).
+- `rapier://runs/{run_id}/record`: a run's full record, redacted when it was
+  saved (JSON).
+
+Each saved run also appears in the client's resource list, titled by kind and
+topic, including runs saved after the server started. The `list_runs` and
+`get_run` tools still work.
+
+### Fixed: `rapier mcp` failed on a fresh install
+
+The `[mcp]` extra allowed any `mcp>=1.2`, so a new install got the mcp 2.x SDK,
+which renamed the server API this version uses. `rapier mcp` then exited with a
+message telling you to install the extra you already had. The extra is now
+capped at `mcp<2`, and if a 2.x SDK is present anyway, `rapier mcp` says so and
+gives the command that fixes it.
+
+## 0.5.2 — 2026-10-16
+
+### Fixed: the report no longer calls a same-vendor review independent
+
+Found on a live run with a single vendor's key, where the reviewer and the
+author were the same model:
+
+- **The report contradicted itself.** "Already fixed under challenge" said
+  "an independent, different-vendor reviewer raised each of these," and the
+  registry section pointed to "the cross-vendor challenge," while "How much to
+  trust this" correctly said the review was not independent. Every section
+  now says what actually happened; a cross-vendor run reads as before.
+- **The progress warning blamed the wrong key.** It said "OPENAI_API_KEY
+  absent; falling back to a Claude reviewer" when the OpenAI key was set and
+  no Claude model was used. It now names the vendor that ran the review.
+- **Arithmetic printed as raw LaTeX.** Math the model wrote as `\( H \times
+  0.60 \)` now reads `H × 0.60` in the report. Only text inside `\( \)` or
+  `\[ \]` is rewritten.
+
+## 0.5.1 — 2026-10-16
+
+### Changed: default models for five OpenAI-compatible vendors
+
+Five built-in defaults named models that a vendor has retired or is retiring. If
+you relied on a vendor's default (no `model:` in your manifest and no
+`RAPIER_MODEL_<VENDOR>` set), **your runs now use a different model.** To keep
+the old one while it still works, name it in your manifest or set
+`RAPIER_MODEL_<VENDOR>`.
+
+| Vendor | Was | Now | Why |
+|---|---|---|---|
+| `openrouter` | `openai/gpt-4o` | `openai/gpt-6-sol` | gpt-4o stops working 2027-01-14. gpt-6-sol is OpenAI's current flagship and costs slightly less. |
+| `deepseek` | `deepseek-chat` | `deepseek-flash` | `deepseek-chat` was retired 2026-07-24, so the old default already fails. |
+| `groq` | `llama-3.3-70b-versatile` | `openai/gpt-oss-120b` | Shut down 2026-08-16, so the old default already fails. Groq names gpt-oss-120b as the replacement. |
+| `together` | `meta-llama/Llama-3.3-70B-Instruct-Turbo` | `openai/gpt-oss-120b` | Leaves Together's serverless tier 2026-10-22. |
+| `gemini` | `gemini-2.5-flash` | `gemini-3.5-flash-lite` | 2.5 Flash is closed to new API users. Google recommends 3.5 Flash-Lite for new projects, at the same price. |
+
+`xai` (`grok-4.3`), `mistral` (`mistral-large-latest`) and `ollama` (`llama3.1`)
+are unchanged. Each was checked against its vendor's deprecation page on
+2026-10-15.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rapier-runtime
-Version: 0.6.1
+Version: 0.6.2
 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
@@ -49,9 +49,11 @@ Free and open source (Apache-2.0). Not monetized.
 
 ---
 
-## Status: pre-alpha — the full ceremony runs end-to-end (M0–M3 complete; M4 in progress)
+## Status: alpha — the full ceremony runs end-to-end (M0–M4 complete)
 
-This is early software, pinned pre-1.0 — but the whole method runs. What works
+This is early software, pinned pre-1.0 — but the whole method runs. The interfaces can still
+change in any minor release. How versions, maturity and evidence are kept apart:
+[docs/versioning.md](docs/versioning.md). What works
 today:
 
 - **The full SPARRING ceremony, end-to-end.** The **Proposer** (divergent

{rapier_runtime-0.6.1 → rapier_runtime-0.6.2}/README.md

@@ -19,9 +19,11 @@ Free and open source (Apache-2.0). Not monetized.
 
 ---
 
-## Status: pre-alpha — the full ceremony runs end-to-end (M0–M3 complete; M4 in progress)
+## Status: alpha — the full ceremony runs end-to-end (M0–M4 complete)
 
-This is early software, pinned pre-1.0 — but the whole method runs. What works
+This is early software, pinned pre-1.0 — but the whole method runs. The interfaces can still
+change in any minor release. How versions, maturity and evidence are kept apart:
+[docs/versioning.md](docs/versioning.md). What works
 today:
 
 - **The full SPARRING ceremony, end-to-end.** The **Proposer** (divergent

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

@@ -1,9 +1,23 @@
 # Rapier — dev status
 
-_Last updated: 2026-10-16 (tag v0.6.0, 250 tests with the mcp SDK)._ A running "where we are /
+_Last updated: 2026-10-16 (tag v0.6.1, 264 tests)._ A running "where we are /
 what's next" so a new session can continue without reconstructing from git log.
 
 ## Done
+- **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
+  valkyrie-sparring-1: a stats-heavy spar
+  (sparring-framework `docs/spars/202610161853-gopnik-pilot-design-review/`)
+  got five false mismatches out of five, because every stated result was
+  checked as a sum of the numbers near it. Fixes: `difference` and
+  `expression` operations (the formula is evaluated as written, by a
+  literal-only evaluator); "not checked" where the operation can't be
+  recovered, or a "sum" quote shows a formula; the agreement margin is 0.5% of
+  the figures (no floor of 1) or half a unit of the last digit the quote
+  shows. Also: the ledger permission test skips where the filesystem ignores
+  chmod (WSL `/mnt/c`). Verified from PyPI: a clean install reports 0.6.1 and
+  the reported standard-error case agrees.
 - **RELEASED (2026-10-16) — `rapier-runtime` 0.6.0 on PyPI. The MCP server runs
   on the mcp 2.x SDK.** Git tag `v0.6.0`;
   https://pypi.org/project/rapier-runtime/0.6.0/. `MCPServer` replaces

rapier_runtime-0.6.2/docs/chatlogs/202610162128.reconcile-false-alarms-0.6.1.md

@@ -0,0 +1,91 @@
+# Fix the arithmetic check's false alarms on formulas and release 0.6.1
+
+**Timestamp**: 2026-10-16 21:28 (local)
+**Project**: rapier-runtime
+**Machine**: Valkyrie
+**User**: Bart Niedner
+**Session**: worktree-valkyrie-rapier-runtime-1
+**Previous session**: [202610162038.five-releases-defaults-report-mcp2.md](202610162038.five-releases-defaults-report-mcp2.md)
+
+## Session summary
+valkyrie-sparring-1 reported that the reconcile stage ("WHETHER THE NUMBERS ADD UP")
+flagged five correct formula results as mismatches in a stats-heavy spar. Fixed the
+cause, two related weaknesses and a test that failed on this machine, then released
+0.6.1 to PyPI.
+
+## Decisions made
+1. **Root cause was the extraction schema, not the arithmetic.** The extractor could
+   only label a relation sum/product/count/percent_of, and a missing operation
+   defaulted to sum, so the model filed formulas as sums. Added `difference`,
+   `expression` (formula transcribed as written, evaluated in code by a literal-only
+   AST evaluator) and `other` (not checked). The model still only extracts; Python
+   still decides.
+2. **"Not checked" over a guess.** A missing operation, `other`, an expression that
+   won't evaluate, or a `sum` whose own quote carries a formula operator
+   (`· × ÷ √ ^ ± ² ³ ⁴`) is unverifiable, never a mismatch. `/` and Markdown `**`
+   are excluded from that guard so unit rates and bold totals are still checked.
+3. **Margin measured against the figures.** The old `max(|s|, |c|, 1.0)` floor let
+   any figure under 1 agree with almost anything. Now: 0.5% of the figures, or half
+   a unit of the last digit shown.
+4. **Precision read from the quote.** JSON drops trailing zeros (0.120 → 0.12), so
+   the allowance comes from the numeral in the aggregate quote that equals the
+   stated value (handles `1,200`, `6e-5`, `6×10⁻⁵`, `%`). Falls back to the number.
+5. **Ledger permission test skips where chmod is ignored** (Bart chose option 1 over
+   changing TMPDIR). It probes its tmp dir and skips only the mode assertion.
+6. **0.6.1** (patch): bug fixes to an existing check, no new interface.
+
+## Files changed
+- Engine: `src/rapier/stages/reconcile.py`
+- Report: `src/rapier/stages/resolver/compose.py` (formula shown on a mismatch;
+  count of unchecked figures; section blurb)
+- Tests: `tests/test_reconcile.py` (+17 tests), `tests/test_pipeline.py`
+- Release/docs: `pyproject.toml`, `CHANGELOG.md`, `docs/STATUS.md`
+
+## Current results
+- Suite: 264 passed (263 + 1 skip when tmp is on /mnt/c).
+- Replaying the stored extraction from the reported run
+  (sparring-framework `docs/spars/202610161853-gopnik-pilot-design-review/20261016185428-spar/`)
+  clears 4 of 5 false alarms. The 5th ("20-point effect") stays a mismatch because
+  that stored extraction labelled it `sum` with no operator in its quote; the new
+  prompt should extract it as `difference`. **Not confirmed with a live run.**
+- PyPI: 0.6.1 published, tag `v0.6.1`. Clean install from PyPI reports 0.6.1 and
+  the reported SE case agrees.
+
+## Bugs found and fixed
+- Reconcile summed formula operands (1857d50).
+- Reconcile margin floor of 1 made sub-1 figures unfalsifiable (dfda3de).
+- Trailing-zero precision lost through JSON (62365e2).
+- `test_ledger_persists_redacted_run` failed on drvfs tmp dirs (f475d2a).
+
+## Environmental discoveries
+- **TMPDIR=/mnt/c/Temp comes from `~/.bashrc:125`** (earlier in the session I
+  guessed it might be set by Claude Code; it is not). On that drive pytest's output
+  capture crashes ("no tests ran") and file modes read 0o777, so both deploy scripts
+  refuse with "suite is red" unless run with `TMPDIR` on the Linux filesystem.
+- `!` commands from the Claude Code prompt get no stdin; the prod script's version
+  confirmation reads empty and refuses. Partner pipes it: `printf '0.6.1\n' | ...`.
+- Recorded machine-specific in Claude memory `computer_Valkyrie.md`. No readiness
+  probe written: the project has no `.loom/readiness.d/`, and the repair (editing
+  `~/.bashrc`, or making the scripts set their own TMPDIR) is a partner decision.
+
+## Surfaced items routed
+None -- no in-flight captures this session.
+
+## What's next
+- Run a fresh spar with `--verify gate` on a stats-heavy topic under 0.6.1 and
+  confirm the "20-point effect" kind of figure is extracted as `difference`.
+- Decide whether `loom-deploy-nonprod.sh` / `loom-deploy-prod.sh` should set a
+  Linux `TMPDIR` themselves when it points at `/mnt/*`, so deploys work from a
+  default shell on Valkyrie.
+- Optional: give `loom-deploy-prod.sh` a `--preview` manifest and a
+  `loom-deploy-holds` check, which /deploy-prod expects and this script lacks.
+
+_Run `/wn` for the ranked what's-next shortlist._
+
+## Commits
+- 1857d50 reconcile: stop summing formulas — add difference/expression ops, "not checked" when unrecoverable
+- dfda3de reconcile: measure the margin against the figures, not a floor of 1
+- 62365e2 reconcile: read a figure's precision from the quote, not the JSON number
+- f475d2a test: skip the owner-only mode check where the filesystem ignores chmod
+- 55b983f release: bump to 0.6.1 (reconcile check: no more false alarms on formulas)
+- 9136648 docs(status): 0.6.1 released — arithmetic check stops flagging correct formulas

rapier_runtime-0.6.2/docs/chatlogs/202611141130.inflight.accountable-agents-gaps.md

@@ -0,0 +1,81 @@
+# In-flight: six improvements from the Accountable Agents / Declarative AI concept papers
+
+**Timestamp**: 2026-11-14 11:30 (local)
+**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
+
+## Source
+
+Thomas Gessler's two public concept papers. Cite these, and only these, in this repo:
+
+- *Declarative AI Architecture: Knowledge Artifacts as System Logic for Generative Systems*, DOI 10.5281/zenodo.20687710
+- *Accountable Agents: Declarative Control Architecture for Operational AI Systems*, DOI 10.5281/zenodo.21850919
+
+The ideas used here, in our words:
+- A control counts as external only if the governed agent cannot change, disable or get around it.
+  Sitting outside the model is not enough.
+- A negative test passes only if the intended control was active and caused the failure.
+- A failure to run is a different outcome from "no decision". The papers name six final states:
+  act, refuse, block, defer, escalate, non-decision.
+- Declared controls should be checked against what actually runs, before deployment.
+- To measure drift, record the version of the method that ran.
+
+Rapier already meets much of this. The method is declared in a manifest outside the models. The
+models only answer API calls and have no tools. Review is cross-vendor and says so when it isn't. The
+run record names each stage, model and vendor. And a verifier error on one artifact gives `flagged`,
+never `clean` (`src/rapier/verify/_vendor/spar_verify_gate.py`, `decide()`). The items below are at
+the edges.
+
+## Items, most useful first
+
+### 1. SCOPE-CANDIDATE: the calling agent can switch a check off (about half a day)
+Over MCP the calling agent picks `verify` (`src/rapier/mcp/server.py`, `spar` / `sparring`).
+`verify="off"` drops the citation gate and the Proposer's traceability gate (`src/rapier/presets.py:73`
+and `:117`). The definitiveness gate always runs. So the agent whose output is being checked chooses
+which checks run.
+- `verify_mode` is recorded in `ceremony.json`. Not yet checked: whether the report tells the reader.
+- Proposal: a minimum level the operator sets (env or config) that a tool argument can't lower, and a
+  report line naming any check that was turned off, and by whom (caller argument or operator config).
+- The operator setting must live where the calling agent can't write it. An env var or config file the
+  agent can edit fails the papers' own test (externality is about authority, not location).
+- Promised publicly on 2026-11-14 (a check the operator requires can't be turned off by the caller; the
+  report says when a check is off and who turned it off). Item 2 was promised the same day.
+
+### 2. BUG-CANDIDATE: "didn't run" reads like "found nothing" (small)
+When the definitiveness verdict is missing, `_verdict_sentence` in
+`src/rapier/stages/resolver/compose.py` (around line 47) says "there were no hard specifics to check,
+or the checker was unavailable". That merges a check that ran and found nothing with a check that
+never ran. A stage that raises is also caught and logged, and the pipeline goes on
+(`src/rapier/pipeline.py:150`, fail-soft), so a crashed gate lands in the same message.
+- Proposal: separate outcomes (`not-run: <reason>` and `nothing-to-check`) in the verdict, the Trust
+  Rider and `ceremony.json`.
+
+### 3. SCOPE-CANDIDATE: compare what the manifest declared with what ran (about half a day)
+- At run time: the Trust Rider lists each declared stage and whether it produced a result, failed soft,
+  or was skipped. `ledger.jsonl` holds the trace tails today, but nothing compares them with the
+  manifest.
+- Before a run (`rapier doctor` or manifest load): warn when a manifest declares no correctness gate,
+  or when a gate's result never reaches the verdict.
+
+### 4. DESIGN-CALL: name the final outcomes
+PASS / FAIL / REVIEW / unchecked map roughly onto block and defer. SPARRING has no formal
+non-decision. A Proposer phase that exits at its cap still in disagreement (`stages/proposer/phase_stages.py`,
+"disagreement-at-cap") is a non-decision: label it, and say what the reader should do next. Keep it
+apart from "a check failed to run" (item 2).
+
+### 5. SCOPE-CANDIDATE: record the method version (small)
+`ceremony.json` has `sparring_version`, and the transcript has the models. There's no hash of the
+manifest (resolved pipeline plus config) that actually ran. Add one, so we can tell whether the same
+inputs under the same method version still give the same result.
+
+### 6. DESIGN-CALL, optional: strict single-vendor mode
+With one vendor available, the reviewer runs on the author's vendor and the report says it is "not an
+independent check". A strict mode would stop and report that no independent check is possible,
+instead of going ahead.
+
+## Out of scope
+Rapier only gives advice and never acts on anything, so the papers' commit boundary and "act is not
+commit" don't apply. Their rule that conflicting validators must not produce a commit is met by
+reporting: objections appear in a "contested" section rather than being merged away.

{rapier_runtime-0.6.1 → rapier_runtime-0.6.2}/docs/mcp-server-scope.md

@@ -35,12 +35,24 @@ Return **both** a human-readable markdown report *and* a structured payload, so
 client can render prose or branch on the result:
 - `report_md` — the composed two-part report (what the CLI prints).
 - `verdict` — `PASS | REVIEW | FAIL | unchecked` (the definitiveness gate).
+- `correctness_check` / `citation_check` — what happened to each check: `ran`,
+  `nothing-to-check` (it ran and there was nothing to judge), or
+  `did-not-run: <reason>` (switched off, crashed, no key, or not in the pipeline).
+  A check that did not run is never reported as one that found nothing.
 - `grounding` — `{gate, grounding_rate, verified, refuted, unverifiable}` from the
   now-live citation gate (the external-canon check).
 - `cross_vendor` — bool, plus `author_vendor` / `reviewer_vendor` (honest
   degradation is visible, not hidden).
 - `standing_objections` — forwarded Proposer dissent, when present.
 
+An operator minimum (`/etc/rapier/policy.json` `{"min_verify": "gate"}`, or
+`RAPIER_MIN_VERIFY`) refuses a `verify` argument below it with
+`{"ok": false, "refused_by": "operator_minimum"}`. No tool argument can change
+the minimum or the file's path; see `src/rapier/operator_policy.py`. It binds callers
+that reach Rapier through its MCP tools or CLI. Code that imports Rapier and
+builds a `Pipeline` directly in its own process is not held to it, and Rapier
+cannot prevent that: keep the policy for agents that only get the tools.
+
 All outputs pass through `secrets.redact_obj` (already the ledger's discipline)
 before leaving the process.
 

rapier_runtime-0.6.2/docs/versioning.md

@@ -0,0 +1,68 @@
+# Versioning and maturity
+
+Rapier keeps three things separate, because they answer different questions:
+
+1. **The version number** says whether an upgrade can break you.
+2. **The maturity stage** says how settled the software is.
+3. **The evidence status** says how far the method itself has been shown to work.
+
+The evidence never goes into the version number. A 1.0 release would mean the software
+contract is stable, not that the method is proven.
+
+## 1. Version number: Semantic Versioning, written as PEP 440
+
+Versions follow [Semantic Versioning 2.0](https://semver.org/), written in
+[PEP 440](https://peps.python.org/pep-0440/) form for PyPI.
+
+**The public contract** is what a version number protects:
+
+- the CLI: commands, flags, and exit codes;
+- the manifest format: stage names, roles, and config keys;
+- the MCP server: tool names and their parameters;
+- the run record: the files under `~/.rapier/runs/<run>/` and the fields in `ceremony.json`.
+
+Anything else, including prompt text, report wording, and internal modules, can change in any
+release.
+
+**Before 1.0:** a breaking change to the contract bumps the minor number (0.6 → 0.7). Everything
+else bumps the patch (0.6.1 → 0.6.2). A deprecated name keeps working, with a warning, for at least
+one minor release before it is removed. The CHANGELOG says so when it goes.
+
+**From 1.0:** a breaking change bumps the major number.
+
+## 2. Maturity stage
+
+The stage is shown in two places that must agree: the PyPI `Development Status` classifier in
+`pyproject.toml`, and the Status line in the README. A stage is earned by meeting its criteria, not
+by declaring it.
+
+| Stage | Classifier | Criteria |
+|---|---|---|
+| Pre-alpha | `2 - Pre-Alpha` | The method doesn't yet run end to end. |
+| Alpha | `3 - Alpha` | The whole method runs end to end, is published, and is tested. The contract can still change in any minor release. |
+| Beta | `4 - Beta` | The contract is frozen except for fixes. The deprecation policy holds. A security review is done. There are users beyond the maintainer. Every check reports whether it ran: a check that never ran is never reported as one that found nothing. The calling agent can't lower a check the operator requires. |
+| Stable | `5 - Production/Stable` | Released as 1.0. The contract is under Semantic Versioning. |
+
+## 3. Evidence status, per instrument
+
+Each governance instrument is rated on its own:
+
+- **Exploratory:** built and used, with no pre-registered test of whether it helps.
+- **Tested:** a pre-registered study was run, and its result is published, whatever it found.
+- **Validated:** a pre-registered study found the effect it predicted.
+
+The instruments are the definitiveness (correctness) gate, the citation gate, anchored correction,
+and the two-part report with its trust rider.
+
+## Where Rapier is now (2026-11-14)
+
+- **Version:** 0.6.1.
+- **Stage:** Alpha. The full ceremony runs end to end, it is on PyPI, the tests pass, and
+  cross-vendor runs are live-proven. The contract is still changing.
+- **Evidence:** every instrument is exploratory. Two pre-registered studies of the resolver are
+  published. In a blind rater test, raters didn't prefer the resolver's answers to a single AI pass.
+  Iterating review toward agreement gave no cleaner answers than one review. Neither study
+  validated the instruments above.
+- **Open for Beta:** a stable contract, a security review, users beyond the maintainer, and the two
+  check-reporting criteria, which are open work today
+  (`docs/chatlogs/202611141130.inflight.accountable-agents-gaps.md`, items 1–3).

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

@@ -9,7 +9,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rapier-runtime"
-version = "0.6.1"
+version = "0.6.2"
 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.1 → rapier_runtime-0.6.2}/src/rapier/cli.py

@@ -299,7 +299,9 @@ def main(argv: list[str] | None = None) -> int:
     run.add_argument("--manifest", required=True, help="path to a pipeline manifest (YAML)")
     add_common(run)
 
-    sub.add_parser("doctor", help="check which AI vendor keys are configured")
+    dp = sub.add_parser("doctor", help="check vendor keys, the operator minimum, and what the "
+                                     "ceremonies declare")
+    dp.add_argument("--manifest", help="also check a custom manifest before running it")
     ip = sub.add_parser("init", help="scaffold a .env.example for vendor keys")
     ip.add_argument("--dir", default=".", help="directory to write .env.example into (default: cwd)")
     sub.add_parser("mcp", help="run the MCP server (stdio) exposing frame/proposer/spar/sparring as tools")
@@ -333,10 +335,12 @@ def main(argv: list[str] | None = None) -> int:
         return {"failed": 1, "unchecked": 3}.get(report["status"], 0)
 
     if args.cmd == "doctor":
-        from .onboarding import doctor_report
+        from .onboarding import doctor_report, method_report
 
         print(doctor_report())
-        return 0
+        text, ok = method_report(getattr(args, "manifest", None))
+        print("\n" + text)
+        return 0 if ok else 1
     if args.cmd == "init":
         from .onboarding import init as _init
 
@@ -373,18 +377,36 @@ 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
+
+        try:
+            decision = decide_verify(
+                getattr(args, "verify", "gate"),
+                "command-line flag --verify"
+                if any(a == "--verify" or a.startswith("--verify=")
+                       for a in (argv if argv is not None else sys.argv[1:]))
+                else "default",
+            )
+        except PolicyError as exc:
+            print(f"refused: {exc}", file=sys.stderr)
+            return 2
         preset = load_preset(
-            args.cmd, settle=getattr(args, "settle", 0), verify=getattr(args, "verify", "gate"),
+            args.cmd, settle=getattr(args, "settle", 0), verify=decision.mode,
             seed=getattr(args, "seed", None), depth=getattr(args, "depth", "standard"),
             reconcile=getattr(args, "reconcile", "gate"),
         )
+        try:
+            decide_independence(getattr(preset, "policy", None))
+        except PolicyError as exc:
+            print(f"refused: {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
         # classification (from a separate call) via --frame.
         seed_meta: dict = {
             "settle": getattr(args, "settle", 0),
-            "verify": getattr(args, "verify", "gate"),
             "reconcile": getattr(args, "reconcile", "gate"),
+            **decision.meta(),
         }
         frame_path = getattr(args, "frame", None)
         if frame_path:
@@ -400,7 +422,18 @@ 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":
-        return _run(Manifest.load(args.manifest), request, args.ledger_dir,
+        from .operator_policy import PolicyError, decide_independence, decide_manifest
+
+        manifest = Manifest.load(args.manifest)
+        try:
+            decision = decide_manifest(manifest.stages)
+            if any(s.stage in ("cross_review", "spark", "pattern_lock", "cut")
+                   for s in manifest.stages):
+                decide_independence(manifest.policy)
+        except PolicyError as exc:
+            print(f"refused: {exc}", file=sys.stderr)
+            return 2
+        return _run(manifest, request, args.ledger_dir, seed_meta=decision.meta(),
                     no_save=getattr(args, "no_save", False))
     return 1  # pragma: no cover