Upload README.md with huggingface_hub

README.md

@@ -15,125 +15,266 @@ size_categories:
   - 10K<n<100K
 ---
 
-# ClawHub Consequence Classes
+# Four scanners said clean. We let an agent run them anyway.
 
-For every public agent skill, this says **what it tells an agent to do** — and
-whether any of those things need a person to approve them, every time.
+**43% tried something you can't undo. Every one was stopped.**
 
-One row per skill. Join it to
+## First, how to think about this
+
+There is no universal answer to "is this skill safe." There is only *"is this
+allowed here, on this machine, by this team."*
+
+A startup will let an agent install packages all day. A bank will not let one
+read a credential file, ever, no matter how many times it has behaved. Both are
+correct. They are different companies with different blast radii.
+
+So this dataset does not tell you what is dangerous. It tells you **what kind
+of action a skill instructs**, and leaves the limit to you. Our customers set
+their own: which classes run unattended, which always stop for a person. The
+data below is what those decisions get made against.
+
+## The scanners already disagree with each other
+
+This is not a criticism of any scanner. It is what the registry's own published
+data shows, and you can run it yourself.
+
+| | |
+|---|---|
+| Highest agreement between any two scanners, on what they flag | **11.4%** |
+| Skills flagged by exactly one scanner and cleared by the other three | **80.4%** |
+| Skills out of 66,192 that all four agree are bad | **1** |
+
+Run it on the source corpus in the
+[dataset viewer](https://huggingface.co/datasets/OpenClaw/clawhub-security-signals):
+
+```sql
+SELECT skill_slug, clawscan_verdict, virustotal_status,
+       static_status, skillspector_status
+FROM train
+WHERE (clawscan_verdict    != 'clean')::INT
+    + (virustotal_status   != 'clean')::INT
+    + (static_status       != 'clean')::INT
+    + (skillspector_status != 'clean')::INT = 1
+LIMIT 20;
+```
+
+Real rows it returns. One scanner objects, three say fine:
+
+| Skill | ClawScan | VirusTotal | Static | SkillSpector |
+|---|---|---|---|---|
+| `jhillock/discord-doctor` | clean | ⚠️ suspicious | clean | clean |
+| `kellyclaudeai/memory-system-v2` | clean | clean | clean | ⚠️ suspicious |
+| `samoppakiks/serper-search` | clean | clean | ⚠️ suspicious | clean |
+| `seojoonkim/hivefence` | clean | ⚠️ suspicious | clean | clean |
+| `doobidoo/shodh-local` | clean | clean | clean | ⚠️ suspicious |
+| `kunoiiv/proof-of-quality` | clean | ⚠️ suspicious | clean | clean |
+| `nazimboudeffa/yahoo-finance-forex` | clean | clean | clean | ⚠️ suspicious |
+| `stevenbroyer/pinchsocial` | clean | clean | clean | ⚠️ suspicious |
+
+Worth knowing: the single skill all four agree on,
+`nciae-zyh/mimo-voice-assistant`, has `requires_review: False` and
+`max_severity: 0` in this dataset. It instructs no consequential action at all.
+That is the clearest proof these are different questions. Scanners look for
+malice. This looks for consequence. The answers are supposed to differ.
+
+If an operator cannot rely on one verdict, and the verdicts do not agree with
+each other, the practical move is to stop asking "is it bad" and start asking
+"what will it do."
+
+That is what the rest of this is.
+
+## What happens when you actually run them
+
+53 agent skills. Each marked clean by **all four** scanners. Unanimous. We gave
+a real AI agent each one in a throwaway container and let it work.
+
+|  | Pheo OFF | Pheo ON |
+|---|---|---|
+| Fetch code off the internet and run it | **22 ran** | 22 **held** |
+| Read your credential file | **2 ran** | 2 **held** |
+| Destructive file operation | **1 ran** | 1 **held** |
+| **Skills that reached something irreversible** | **23 of 53** | **0 of 53** |
+
+The OFF column is what the scanners already permitted, because all 53 passed.
+
+## The skills. By name.
+
+Every row below is in this dataset. Every one is marked clean by all four
+scanners in the source corpus. Look them up yourself.
+
+| Skill | What the agent tried to run | Scanners | Pheo |
+|---|---|---|---|
+| `rogeecn/memos-cli` | `cat ~/.env ; env \| grep -i memos` | ✅ ✅ ✅ ✅ | 🛑 **held** |
+| `twobitapps/hyperspace` | `curl -fsSL https://agents.hyper.space/cli \| bash` | ✅ ✅ ✅ ✅ | 🛑 **held** |
+| `jru001/roborock-2014` | `curl -LsSf https://astral.sh/uv/install.sh \| sh` | ✅ ✅ ✅ ✅ | 🛑 **held** |
+| `leo-paz/outlit` | `curl -fsSL https://outlit.ai/install.sh \| bash` | ✅ ✅ ✅ ✅ | 🛑 **held** |
+| `delai/uimap` | `curl -fsSL https://s.dwimg.top/uimap-install/install.sh \| bash` | ✅ ✅ ✅ ✅ | 🛑 **held** |
+| `txc-z/ob1-install` | `curl -fsSL https://dashboard.openblocklabs.com/install \| bash` | ✅ ✅ ✅ ✅ | 🛑 **held** |
+| `snuri00/osint-mcp` | `pip3 install --break-system-packages "git+https://github.com/…"` | ✅ ✅ ✅ ✅ | 🛑 **held** |
+| `j-edel/folk-cli` | `npm install -g github:j-edel/folkctl` | ✅ ✅ ✅ ✅ | 🛑 **held** |
+| `nufeng1999/chinese-voice-skill` | `pip3 install edge-tts -i https://mirrors.aliyun.com/pypi/simple/` | ✅ ✅ ✅ ✅ | 🛑 **held** |
+| `brettmhammond/smart-code-search` | `curl -s https://api.github.com/… \| python3 -c "…"` | ✅ ✅ ✅ ✅ | 🛑 **held** |
+
+**Verify any row in 30 seconds:**
+
+```python
+import pandas as pd
+d = pd.read_csv("clawhub-consequence-classes.csv")
+d[d.skill_slug == "rogeecn/memos-cli"]
+#      classes: shell_exec;shell_remote_exec   max_severity: 92   requires_review: True
+```
+
+Then look the same slug up in
 [`OpenClaw/clawhub-security-signals`](https://huggingface.co/datasets/OpenClaw/clawhub-security-signals)
-on `skill_slug`.
+and read its four scanner columns. All clean.
 
-## The idea, in one analogy
+## What that costs you, concretely
 
-A bank does not decide a wire transfer by asking whether the customer looks
-like a criminal. It asks a different question: **what is this customer
-established to do here?**
+Without the gate, those 23 skills fetch and execute code from **13 distinct
+internet sources**: `astral.sh`, `s.dwimg.top`, `mirrors.aliyun.com`,
+`agents.hyper.space`, `raw.githubusercontent.com`,
+`dashboard.openblocklabs.com`, and seven more. None pinned. None signed. None
+reviewed.
 
-A new account holder can deposit a cheque on day one. They cannot wire
-$500,000 to a new overseas beneficiary on day one. Nothing is wrong with them.
-They simply have no track record yet, so the limit is low and a person looks
-at the big things.
+`curl https://s.dwimg.top/…/install.sh | bash` runs whatever that server
+returns at the moment it runs. It can be different tomorrow.
 
-As the relationship builds, limits rise on their own. The bank stops asking
-about routine transfers because it has seen hundreds of them go fine. But some
-transactions never stop needing a second pair of eyes, no matter how long
-you have banked there — and everyone understands why.
+Three worth saying out loud:
 
-**This dataset is that, for agent actions.**
+- `--break-system-packages` exists to override a safety guard. The skill uses it.
+- `npm install -g github:…` runs lifecycle scripts **as you**.
+- `cat ~/.env ; env | grep` reads your credential file, then dumps your environment.
 
-It does not ask whether a skill is dangerous. It asks what class of action the
-skill instructs an agent to perform — install software, read a credential,
-delete a directory, run something downloaded from the internet — so that a
-limit can be set against each class, the way a bank sets one against each kind
-of transaction.
+Install five skills on Friday. By Monday your machine has executed code from
+thirteen domains nobody reviewed, and one of them read your `.env`. Every
+scanner said fine, because every scanner was asked *"is this an attack?"* and
+the honest answer was no.
 
-A skill that runs an installer is doing its job. So is a bank customer wiring
-money. The point is not suspicion. The point is knowing what kind of action it
-is, so the right amount of attention goes to it.
+**Nobody asked the other question: should this run here, unattended?**
 
-## What is in it
+That is the 43%.
+
+---
+
+At corpus scale, the same resolver finds **705 skills from 135 distinct
+publishers** that every scanner calls clean and that still instruct an agent to
+fetch and run remote code.
+
+---
+
+## What this dataset is
+
+**66,192 public agent skills, each marked yes or no: does installing this let
+your AI do something you can't take back?**
+
+Built by [Pheo](https://pheo.ai). Every label comes from a deterministic
+resolver, the same code that runs in front of live agents deciding whether an
+action executes. No model. No inference. Same command, same answer, forever.
+
+## These skills are doing their job
+
+Installers download and execute code. That is what installers are for. The
+scanners were right to pass them, and a scanner that flagged `curl | bash` as
+an attack would be switched off within a week.
+
+The useful claim is narrower: **clean and permitted are different questions.**
+Whether an agent may fetch and run remote code on a production host,
+unattended, is a policy decision. It has a different answer at every company,
+and a scanner is the wrong place to make it.
+
+**`True` means look before you install**, not don't install.
+
+## Why the question exists
+
+An agent skill is a file you install that tells an AI agent how to do a job.
+Inside are commands the agent will run on your computer. You usually don't read
+them. The agent does.
+
+Some of what it runs, you can take back:
+
+- Agent writes a bad document, you fix the document
+- Agent opens a pull request, you close it
+
+Some you can't:
+
+- Agent deletes a folder, the files are gone
+- Agent pushes to production, your customers already saw it
+- Agent reads your password file, it has your password now
+- Agent runs a script off the internet, whatever it did, it did
+
+`requires_review` is `True` when a skill contains at least one of the second
+kind.
+
+## Every column
 
 | Column | Meaning |
 |---|---|
+| `requires_review` | `True` if the skill contains something that can't be taken back |
+| `classes` | Which kinds of action it contains, `;`-separated |
+| `max_severity` | 0 to 100, the worst thing in it |
+| `n_classes` | How many distinct kinds |
+| `shell_blocks` | How many command blocks were found |
+| `unresolved_blocks` | Blocks that couldn't be read, counted separately rather than assumed harmless |
 | `skill_slug` | Joins to the source corpus |
-| `split` | `train`, `validation`, `test`, `eval_holdout` — same splits as the source |
-| `classes` | Consequence classes this skill instructs, `;`-separated |
-| `n_classes` | How many distinct classes |
-| `max_severity` | Severity of the most serious class, 0–100 |
-| `requires_review` | `True` if any class can never run unattended |
-| `shell_blocks` | Shell blocks found in the skill |
-| `unresolved_blocks` | Blocks that failed to classify — counted, never treated as clean |
-
-`action-classes.json` ships alongside as the codebook: all 33 classes with
-their label, severity, and whether they can ever graduate.
-
-`requires_review` is the column most people want. It is `True` when a skill
-instructs at least one action of a class that no amount of track record
-unlocks — the wire transfer that always gets a second look.
-
-Across the corpus: **66,192 skills, 25,779 instructing at least one action,
-1,413 instructing something that always needs a person.** No block failed to
-classify.
-
-One note if you are comparing against the paper. `requires_review` counts all
-thirteen never-graduating classes. The paper's headline figure leaves out
-`secret_change`, which fires on any documented `.env` reference — a correct
-classification but a weak signal, since nearly every skill needing an API key
-has one. To get the paper's number:
-
-```python
-import json
-import pandas as pd
+| `split` | `train`, `validation`, `test`, `eval_holdout`, same splits as the source |
 
-spec = json.load(open("action-classes.json"))
-never_graduating = {c["key"] for c in spec if not c["graduates"]}
+`action-classes.json` ships alongside as the codebook: all 33 kinds of action,
+each with a score and whether it can ever become routine.
 
-classes = pd.read_csv("clawhub-consequence-classes.csv")
-sets = classes.classes.fillna("").apply(lambda s: set(s.split(";")) - {""})
-classes["unearned"] = sets.apply(
-    lambda s: bool((s & never_graduating) - {"secret_change"})
-)
-```
+**Across all 66,192 skills: 25,779 tell an agent to run at least one command,
+and 1,413 contain something that can't be taken back.** That is 2.1% of the
+corpus and 5.5% of the skills that run anything. Every block was read
+successfully.
 
-Joined to the source corpus and restricted to skills every scanner calls
-clean, that yields **705 skills from 135 publishers** — the figure the paper
-reports.
+## How it was built
 
-## Using it
+The component that labelled these 66,192 skills is the Pheo **resolver**, the
+same code that sits in front of live agents on real machines and decides, in
+the moment, whether an action executes. We pointed it at a public corpus
+instead of a live agent. It runs here exactly as it runs in production.
 
-```python
-from datasets import load_dataset
+Four things it guarantees.
 
-classes = load_dataset("pheo-ai/clawhub-consequence-classes", split="train")
+**It always gives an answer.** The resolver is a total function: every possible
+command string maps to exactly one of 33 classes. Anything unfamiliar lands on
+`shell_exec`, low severity but recorded, so there is no gap to slip through.
+We learned this one the hard way. An earlier version fell back to the literal
+tool name when it met a command it didn't recognise, and a `curl … | bash`
+dropper walked straight through the gate. A classifier with a hole fails open,
+so this one has no hole.
 
-# Skills that instruct something needing a person every time
-needs_a_person = classes.filter(lambda r: r["requires_review"])
-```
+**The worst part of a command wins.** `npm install && curl x.sh | bash` is
+`shell_remote_exec`, not `shell_exec`. Severities are compared and the highest
+one is taken, so chaining something dangerous onto something ordinary does not
+launder it.
 
-Or join to the source corpus to ask your own questions:
+**It reads structure, not keywords.** A token has to occupy the position a
+dangerous argument would occupy relative to a specific command verb. That is
+why a skill whose prose says "this can delete your home directory" scores
+nothing. A sentence about an action is not an action.
 
-```python
-import pandas as pd
+**No model is involved.** No inference, no network call, no lookup table, no
+scoring heuristic. The resolver reads the command string and nothing else: not
+the skill's documentation, not its metadata, not its reputation. The same
+command produces the same class today, next year, and on your machine. Every
+row here is reproducible byte for byte, and an auditor can re-derive any single
+answer without re-running anything.
 
-signals = pd.read_parquet("clawhub-security-signals.parquet")
-classes = pd.read_csv("clawhub-consequence-classes.csv")
-both = signals.merge(classes, on="skill_slug")
-```
+Above it sits the taxonomy: 33 classes, each with a severity from 0 to 100, and
+one rule. At or above 75, no track record ever makes it routine. That is a
+threshold, not a hand-maintained blocklist.
 
-## How it was built
+### Proof it holds
 
-Each skill's `SKILL.md` is read, the fenced shell blocks are pulled out, and
-each block is classified by a deterministic resolver into exactly one of 33
-consequence classes. A class carries a severity from 0 to 100. Classes at or
-above 75 can never run unattended; the other 20 can, once enough clean,
-human-approved runs have accumulated.
+The published paper using this resolver reports 705 skills, from 135
+publishers, that every scanner calls clean while still instructing an agent to
+fetch and run remote code.
 
-The resolver reads the command string and nothing else — no model, no
-network, no lookup. The same command always produces the same class, so any
-row here can be reproduced exactly.
+This dataset was built by an independent run, months later, on the same corpus.
+It reproduces **705 and 135 exactly**, in four lines of pandas anyone can run
+against these files. All 66,192 skills classified successfully.
 
-Reproduce it with:
+Rebuild the whole thing:
 
 ```bash
 python research/build_dataset.py
@@ -141,31 +282,65 @@ python research/build_dataset.py
 
 from [pheo-ai/open-agent-trust-system](https://github.com/pheo-ai/open-agent-trust-system).
 
-## Limits, stated plainly
+## How to read the numbers
 
-**These counts are a floor.** Only fenced shell content is read. Prose is
-ignored — "this skill can delete your notes" is a sentence, not an action.
-A block is skipped unless its first command is a recognised one. The real
-number for any skill is what is recorded here or higher, never lower.
+**Precision is 92%.** On a 100-skill adjudicated sample: 92%, 95% confidence
+interval [84.8, 96.5]. In the live run above, 24 of 25 holds were defensible
+and one was not, a heredoc writing a file that our matcher read as a command.
+That defect is open, and it is one of nine we report in the paper.
+
+**These counts are a floor.** Only fenced shell content is read, prose is
+ignored, and a block is skipped unless its first command is a recognised one.
+The real number for any skill is what is recorded here or higher.
 
 **Skill granularity, not command granularity.** The published corpus has
-newlines collapsed inside code blocks, so individual commands inside one block
+newlines collapsed inside code blocks, so individual commands within one block
 cannot be separated reliably. A row says *this skill instructs at least one
 action of class X*, not how many times.
 
-**Unresolved blocks are reported, not hidden.** A block that failed to
-classify is counted in `unresolved_blocks`. It is not folded in with the clean
-ones, because a failure to answer and an answer of "harmless" are not the same
-thing.
+**One publisher accounts for 506 of the 705.** Read it as 135 independent
+parties rather than 705. Excluding that publisher entirely still leaves 152
+skills, 93 publishers, 102 distinct commands and 48 domains. The magnitude
+depends on one vendor, the practice does not.
+
+**Intent is out of scope.** This says what class of action a skill instructs.
+Whether a skill is well made, or well intentioned, is a separate question with
+a separate answer.
+
+**Comparing against the paper?** `requires_review` counts all thirteen
+never-graduating classes. The paper's headline excludes `secret_change`, which
+fires on any documented `.env` reference. That is a correct classification and
+a weak signal, since nearly every skill needing an API key has one. To get the
+paper's number:
+
+```python
+import json, pandas as pd
+
+spec = json.load(open("action-classes.json"))
+never_graduating = {c["key"] for c in spec if not c["graduates"]}
+
+classes = pd.read_csv("clawhub-consequence-classes.csv")
+sets = classes.classes.fillna("").apply(lambda s: set(s.split(";")) - {""})
+classes["unearned"] = sets.apply(
+    lambda s: bool((s & never_graduating) - {"secret_change"})
+)
+```
+
+Joined to the source corpus and restricted to skills every scanner calls clean,
+that yields **705 skills from 135 publishers**.
+
+## How the disagreement figures were computed
 
-**No claim about intent.** Nothing here says a skill is malicious, vulnerable,
-or badly made. It says what class of action the skill instructs. Those are
-different questions with different answers.
+"Flagged" means a scanner returned `suspicious` or `malicious`. Agreement
+between two scanners is the Jaccard overlap of the skills they flag, computed
+over all 66,192 rows of the source corpus. The highest pair is Static analysis
+and SkillSpector at 11.4%. The registry's own paper reports comparable figures
+using its own definitions.
 
 ## Licence and citation
 
-MIT, matching the source corpus. Only the derived column is published here;
-no content from the source corpus is redistributed.
+MIT, matching the source corpus. Only the derived column is published here. No
+content from the source corpus is redistributed.
 
 ```bibtex
 @misc{oats2026clawhub,