docs: add harness-agnostic running guide, sandbox tips, and Claude Code 39% baseline

README.md

@@ -77,6 +77,118 @@ Three pass routes are tagged in `pass_route.txt` for auditability: `exit_0`, `va
 
 - 168 of the 3044 rows have an empty `canary_substrings` list (the deleted body uses only identifiers that already appear elsewhere in the contract — common for ERC20-style getters). For these rows B3 enforcement degrades to best-effort; the canary-grep is a no-op and only the stub-residue + diff-fuzz checks remain. Auditors who want strict B3 enforcement should filter to rows with non-empty canaries.
 
+## Running it yourself
+
+The dataset is harness-agnostic: any agent runner that can stage two tarballs and exec a Python scorer inside a sandbox container can use it. The only fixed contract is the layout the scorer expects:
+
+```
+/work/                         <- agent's editable workspace
+  foundry.toml
+  src/<contract_name>.sol      <- target file; one function body is `revert("TODO");`
+
+/scoring/                      <- never visible during the agent loop (B3)
+  manifest.json                <- resolved_solc_version, contract_name, fuzz settings, canaries
+  origin/<contract_name>.sol   <- ground-truth contract
+
+/logs/verifier/                <- scorer writes results here
+  reward.txt                   <- single float in [0, 1]
+  scoring_log.txt
+  diffusc_stdout.txt / diffusc_stderr.txt
+  echidna_stdout.txt / echidna_stderr.txt
+  b3_violation.txt             <- present iff B3 canary check fired
+  slither.txt                  <- side metric (not used in reward)
+```
+
+### Step-by-step
+
+```python
+from datasets import load_dataset
+import base64, io, tarfile, json, pathlib
+
+ds = load_dataset("samscrack/solidity-eval-2026", "lite", split="train")
+row = ds[0]
+
+# 1. Stage the workspace into /work BEFORE the agent runs.
+ws = base64.b64decode(row["workspace_tar"])
+with tarfile.open(fileobj=io.BytesIO(ws), mode="r:gz") as t:
+    t.extractall("/path/to/sandbox/work")
+
+# 2. Run your agent against /work (forge build / forge test / edit /work/src).
+#    Disable web/browser tools (B2 — verified contracts are public on Etherscan).
+#    Do NOT mount or expose /scoring during this step.
+run_my_agent(workspace="/path/to/sandbox/work", prompt=row["prompt_context"])
+
+# 3. After the agent returns, stage the scoring assets and run the scorer.
+sc = base64.b64decode(row["scoring_tar"])
+with tarfile.open(fileobj=io.BytesIO(sc), mode="r:gz") as t:
+    t.extractall("/path/to/sandbox/scoring")
+
+# 4. Run the in-image scorer. Use the reference image as-is.
+#    (The same container used for the agent loop is fine — see "Sandbox tips" below.)
+#    docker run --rm \
+#      -v /path/to/sandbox/work:/work \
+#      -v /path/to/sandbox/scoring:/scoring \
+#      -v /path/to/sandbox/verifier:/logs/verifier \
+#      samscrack/solidity-eval-sandbox:dev \
+#      python /opt/scoring/run_diffusc.py
+
+reward = float(pathlib.Path("/path/to/sandbox/verifier/reward.txt").read_text().strip())
+```
+
+### Reference scorer image
+
+```
+samscrack/solidity-eval-sandbox:dev
+```
+
+Bundles Foundry 1.6.0-nightly, Echidna 2.2.3 (SolBench fork), Diffusc + Slither 0.9.3 (`webthethird/slither.git@dev-diffusc-testing`), solc-select with every patch of 0.5.x–0.8.x installed, and `/opt/scoring/run_diffusc.py`.
+
+A standalone smoke test that does not depend on a harness is included at the eval repo's `scoring-smoke/run_scoring_smoke.sh`: it builds an identical-candidate (`reward=1`) and a wrong-direction-candidate (`reward=0`) case and runs the scorer on each.
+
+### Sandbox tips (lessons from running this end-to-end)
+
+1. **Persist the same sandbox container across staging → agent → scoring.** Each phase uses different tarballs, but the container's filesystem is the only place that links them. Don't tear down the container between phases — the agent's edits to `/work/src/<C>.sol` are exactly what the scorer reads.
+
+2. **The reference image stores solc-select state at `/root/.solc-select`** and exposes it via a symlink at `/opt/py/.solc-select`. If your harness bind-mounts `/root` (e.g. for an isolated agent home dir), that symlink breaks and the scorer fails on `solc-select use <X>`. Either:
+   - don't bind-mount `/root`, or
+   - layer a derived image that materializes the symlink:
+     ```dockerfile
+     FROM samscrack/solidity-eval-sandbox:dev
+     RUN test -L /opt/py/.solc-select && \
+         cp -a /root/.solc-select /opt/py/.solc-select.real && \
+         rm /opt/py/.solc-select && \
+         mv /opt/py/.solc-select.real /opt/py/.solc-select
+     ```
+
+3. **The agent loop budget should comfortably exceed any single command timeout your harness enforces.** Echidna fuzzing runs up to `fuzz_timeout_s` (default 300s) in `manifest.json`; the scorer wrapper adds compile/setup overhead. A 600s foreground-command cap will silently kill scoring mid-run. Configure ≥ `fuzz_timeout_s + 120`.
+
+4. **CLI agents (Claude Code, aider, etc.) shouldn't receive the prompt as a command-line argument.** The 14–18 KB prompts contain Solidity code with substrings (` & `, `&&`, `;`) that trip many "is this a long-lived process / dangerous command" guards even inside shell quotes. Pipe the prompt via stdin or pass it as a file path:
+   ```bash
+   claude --print --max-turns 40 < /work/.agent_prompt.md
+   ```
+
+5. **Reference image rebuild for embedded-CLI agents.** If you want to run a coding-agent CLI (Claude Code, aider) inside the sandbox, layer it on top of the reference image and apply the symlink fix from (2) at the same time. Example for Claude Code:
+   ```dockerfile
+   FROM samscrack/solidity-eval-sandbox:dev
+   RUN apt-get update && apt-get install -y --no-install-recommends curl ca-certificates gnupg \
+    && curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
+    && apt-get install -y --no-install-recommends nodejs \
+    && rm -rf /var/lib/apt/lists/* \
+    && npm install -g @anthropic-ai/claude-code
+   RUN test -L /opt/py/.solc-select && \
+       cp -a /root/.solc-select /opt/py/.solc-select.real && \
+       rm /opt/py/.solc-select && \
+       mv /opt/py/.solc-select.real /opt/py/.solc-select
+   ```
+
+## Reference baseline
+
+| Agent | Split | Pass rate | Notes |
+| --- | --- | --- | --- |
+| Claude Code 2.1.128 (Anthropic API default model) | `lite` | **39.0%** (78/200, 1 timeout) | 16-way concurrency, 40 max-turns, default fuzz settings (`fuzz_timeout_s=300`, `fuzz_test_calls=50000`, `fuzz_seed=0xDEADBEEF`). Reference sandbox image extended with Claude Code per the Dockerfile snippet above. Wall-clock ~34 min on a 32-core host. Run via `hermes-agent`'s `solidity_eval` environment with `agent_backend: claude-code`, `terminal_backend: docker`. |
+
+A non-trivial fraction of failures on `lite` come from B3 canary false-positives where the deleted function legitimately requires common Solidity primitives (`keccak256`, `encodePacked`, addresses unsorted via `sortTokens`, etc.). The ground-truth canary list is generated by token-overlap with the deleted function body and was not pruned for these false-positives in the v0 build; this is the dominant source of noise on the `lite` baseline. Filter to rows where the canary set excludes those tokens if you want a less-noisy slice.
+
 ## Provenance
 
 - Source corpus: SolBench (https://github.com/ZaoyuChen/SolBench, MIT, FSE 2026), specifically the RACR-4k LCS subset.