rigorrun 0.1.0 → 0.2.0

package/README.md

@@ -12,10 +12,31 @@ npx rigorrun
 
 Open the URL it prints. That is the whole install.
 
-**Early Access · v0.1.** It does what this page says and it is young. The
+**Early Access · v0.2.** It does what this page says and it is young. The
 limits are written down and marked one by one, rather than left for you to
 find: [the v1 gap audit](https://github.com/Konuktor/rigorrun/blob/master/docs/V1_GAP_AUDIT.md).
 
+## Or start with a server you already use
+
+An MCP server can annotate a tool `readOnlyHint: true`. Nothing checks that.
+
+```bash
+npx rigorrun verify npm:@modelcontextprotocol/server-memory@2026.8.31
+```
+
+No project, no browser, no agent, nothing to configure first. It pins the server
+to the exact bytes the registry published, runs it in a container with no
+network and no access to your machine, calls each tool with arguments derived
+from its own schema, and reads the filesystem before and after to see what
+actually changed — then compares that against what the server declared.
+
+Exit `0` verified · `1` a declaration was contradicted · `2` it could not run ·
+`3` it ran and established too little to be worth much.
+
+**Needs Docker.** Only `npm:` and `dir:` references, and only stdio servers.
+Against four published servers nobody here wrote, it exercised **19 of 37
+tools**; the rest are named with reasons in every record it writes.
+
 ## What it does
 
 You have an agent that calls tools. You need to know whether it can do a real
@@ -32,6 +53,30 @@ it and reads your system to find out what actually happened.
      RigorRun:   you do the job once   →  RigorRun writes the tests
 ```
 
+## How strongly was it verified?
+
+RigorRun tells you how strongly each result was verified, on every result:
+
+- **AUTHORITATIVE** — checked against direct, trusted state.
+- **PARTIAL** — verified through the reads your system exposes. A normal
+  connected MCP server, whose state RigorRun reads back through the tools you
+  nominated, is **PARTIAL** — the common, honest case, not a defect.
+- **OBSERVATIONAL** — actions were observed but the final state could not be
+  independently proven (e.g. a browser with nothing readable attached).
+
+`AUTHORITATIVE` is claimed only where RigorRun genuinely has authoritative state
+access. Against your own system the honest label is usually `PARTIAL`, and it is
+shown on the same line as the verdict.
+
+## What it can build depends on your system
+
+RigorRun generates every case it can safely and reproducibly verify, and tells
+you what it could not test. A system it can **seed and reset** yields the
+richest suite (boundary and adversarial cases, repeated destructive checks). A
+system without a reset still works, but produces fewer cases, disables repeated
+mutating cases, reports isolation `NONE`, and verifies `PARTIAL`. Best results:
+a staging or scratch environment with read-back and a reset.
+
 ## Why it runs locally
 
 Your MCP server, your internal API and your staging box are usually not
@@ -48,12 +93,15 @@ infrastructure, because there is no path by which they could.
   instance, with a way to reset it.
 - **An agent.** If it speaks MCP it works unchanged; RigorRun hands it a URL —
   whether your agent listens on an address or is a command RigorRun runs. If it
-  does not speak MCP, about ten lines of the agent SDK.
+  does not speak MCP, about ten lines of plain HTTP — there is no package to
+  install; the protocol is documented at
+  [docs/HTTP_AGENT.md](https://github.com/Konuktor/rigorrun/blob/master/docs/HTTP_AGENT.md).
 
 ## Commands
 
 ```bash
 npx rigorrun                              # start the runner and open the interface
+npx rigorrun verify <server-ref>          # what does this server's tools actually do?
 npx rigorrun doctor                       # check this machine and every project
 npx rigorrun projects                     # what is on this machine
 npx rigorrun run --project <id>           # run the suite
@@ -71,7 +119,7 @@ Setting a project up needs the interface; running and gating it does not. It has
 been used successfully by the people who wrote it and is now looking for people
 who did not.
 
-Every capability is marked WORKING, PARTIAL or MISSING in
+Every capability is marked WORKING, PARTIAL, DEMO-ONLY, BROKEN or MISSING in
 [the v1 gap audit](https://github.com/Konuktor/rigorrun/blob/master/docs/V1_GAP_AUDIT.md),
 with how each one was checked. Read it before you rely on this for anything
 that matters.