Build SCOPE benchmark

README.md

@@ -0,0 +1,172 @@
+---
+license: mit
+task_categories:
+  - text-classification
+language:
+  - en
+configs:
+  - config_name: fitness_coaching
+    data_files:
+      - split: test
+        path: fitness_coaching/test-*
+      - split: train
+        path: fitness_coaching/train-*
+  - config_name: message_repetition_with_escalation
+    data_files:
+      - split: test
+        path: message_repetition_with_escalation/test-*
+      - split: train
+        path: message_repetition_with_escalation/train-*
+  - config_name: plan_verification
+    data_files:
+      - split: test
+        path: plan_verification/test-*
+      - split: train
+        path: plan_verification/train-*
+  - config_name: finance_tile_resolution
+    data_files:
+      - split: test
+        path: finance_tile_resolution/test-*
+      - split: train
+        path: finance_tile_resolution/train-*
+---
+
+# SCOPE: Compiling Natural-Language Policies into Neurosymbolic Predicate Programs
+
+The SCOPE benchmark evaluates guardrail classifiers on policies that are too compound to be checked in one step. Each task pairs a single natural-language rule with inputs that satisfy or violate it for distinct, often interacting reasons, so a correct verdict depends on resolving several sub-questions rather than matching a surface pattern. The tasks span recommendation output verification, conversational policy enforcement, agentic output verification, and best-match reference resolution.
+
+| Dataset | Domain | Input Type | Train | Test |
+|---|---|---|---|---|
+| `fitness_coaching` | Recommendation output verification | Profile + message + critic verdict | 103 | 71 |
+| `message_repetition_with_escalation` | Conversational policy enforcement | Multi-turn dialogue | 85 | 286 |
+| `plan_verification` | Agentic output verification | Full message trace | 82 | 81 |
+| `finance_tile_resolution` | Best-match reference resolution | Conversation + on-screen tile list | 39 | 124 |
+
+## Structure
+
+All four subsets use the same columns, so one loader reads them all.
+
+Each task's rule lives in [`task_definitions.json`](./task_definitions.json), keyed by config name, and in every parquet's schema metadata under `task_definition`. It is the same text for every row of a task, so it is stored once rather than repeated per row. An entry holds:
+
+- `cluster` — the full rule text the classifier is given
+- `labels` — the answer space, where it is fixed
+- `dynamic_labels` — how to derive the candidate set, where it is per-sample
+- `multi_labels` — whether an answer is a set rather than a single choice
+
+```python
+import json
+from datasets import load_dataset
+from huggingface_hub import hf_hub_download
+
+name = "fitness_coaching"
+ds = load_dataset("Plurai/SCOPE", name, split="test")
+tasks = json.load(open(hf_hub_download("Plurai/SCOPE", "task_definitions.json",
+                                       repo_type="dataset")))
+rule = tasks[name]["cluster"]
+```
+
+Per row:
+
+- **`sample`** — the input block, exactly the text the classifier is given. What a block contains differs by task and is described in each section below.
+- **`overall_label`** — the gold answer, always a string.
+- **`rationale`** — why the row carries its label. Generated from the human-annotated samples, not written by the annotators. On `train` only.
+- **auxiliary columns** (optional) — authors' notes, not shown to the classifier. On `test` only.
+
+## Fitness coaching
+
+A fitness recommendation system produces short coaching messages, and an automated critic judges each message against multiple style-and-safety dimensions, emitting verdict and reasoning. The task is to audit the critic: given a message and the critic's evaluation of it, decide whether the critic's judgment was correct.
+
+The rubric covers word count, sentence count, actionability, non-judgmental phrasing, absence of gamification, physical safety, and grounding in the user's system state. A sample is labeled `Pass` when the message satisfies every dimension and the critic accepted it, and `Fail` when the message genuinely violates a dimension and the critic rejected it citing that violation. Everything else is a `Bug`, which covers three distinct failure modes: a clean message rejected, a violating message accepted, and a correct rejection supported by an inapplicable reason. The `Bug` case is what makes the task hard: a classification model needs both to judge the coaching message and compare it with the critic's verdict and reasoning. An inconsistency between the judgments of the coaching message, the verdict and the reasoning is likely to lead to a wrong label.
+
+### Columns
+
+| column | description |
+|---|---|
+| `sample` | Four XML-style tags, one per line, each omitted when its value is empty:<br>`<system_state>` — the user's profile and state<br>`<coaching_message>` — the message being judged<br>`<eval_verdict>` — the critic's judgment of the message<br>`<eval_reasoning>` — the dimensions the critic cited, as a JSON list of `{Dimension, Evidence}` entries; empty when the critic accepted the message |
+| `overall_label` | The gold answer: `Pass`, `Fail`, `Bug`. |
+
+**Rule:** the `fitness_coaching` entry in [`task_definitions.json`](./task_definitions.json) — `cluster` and `labels`.
+
+<details><summary>Label distribution</summary>
+
+`train` — 103 rows. `Fail`: 43, `Bug`: 36, `Pass`: 24
+
+`test` — 71 rows. `Bug`: 29, `Fail`: 24, `Pass`: 18
+
+</details>
+
+## Message repetition with escalation
+
+Given a complete customer-support conversation of alternating user and agent turns, the dataset labels each conversation as `True` or `False`, depending on whether the agent handled escalation correctly. The task defines escalation as warranted when the user re-raises the same unresolved intent at least three times. The repetition can be either verbatim or rephrased. A conversation counts as escalated when the agent's final reply connects the user to a human. A label of `True` is given to a sample when the action taken by the agent matches what was warranted, in either direction, and `False` otherwise.
+
+This task presents two challenges. First, it requires computing two independent properties of the input and comparing their values. Second, one of these properties involves counting occurrences in a long and complex input, which is known to be particularly difficult for non-reasoning models.
+
+Inspired by [DynaGuard](https://arxiv.org/abs/2509.02563), this dataset contains 286 human-annotated test samples, distributed across four categories: by escalation, 73 with fewer than three repeated intents and no escalation, 69 with three or more repeated intents but no escalation, and 70 with escalation but fewer than three repeated intents. The first two categories are labeled `True`, as the agent's action matches whether escalation is warranted, while the latter two are labeled `False`.
+
+### Columns
+
+| column | description |
+|---|---|
+| `sample` | The full conversation as a string of alternating &lt;User&gt;...&lt;/User&gt; and &lt;Agent&gt;...&lt;/Agent&gt; turns; the FINAL turn is the agent's reply being judged. |
+| `overall_label` | The gold answer: `True`, `False`. |
+| `has_user_repetition` (`test` only) | Gold for the first sub-question — did the user re-raise the same unresolved intent at least three times. `1`/`0`. |
+| `is_escalated` (`test` only) | Gold for the second sub-question — did the agent actually escalate. `True`/`False`. |
+
+**Rule:** the `message_repetition_with_escalation` entry in [`task_definitions.json`](./task_definitions.json) — `cluster` and `labels`.
+
+<details><summary>Label distribution</summary>
+
+`train` — 85 rows. `False`: 44, `True`: 41
+
+`test` — 286 rows. `True`: 147, `False`: 139
+
+</details>
+
+## Plan verification
+
+This dataset, built upon the [GAIA](https://arxiv.org/abs/2311.12983) benchmark, contains full message traces of an agent tasked with constructing a research plan to solve a user request using a set of available tools. A plan is considered valid if it satisfies three independent conditions: it refers only to tools and collaborators present in the trace; it refers to tools abstractly rather than specifying explicit tool calls; and it terminates with an `<end_plan>` tag.
+
+Because the conditions are conjunctive and independent, a single violation of any one flips the label. The three conditions demand quite different competencies: semantic grounding against a tool list, a stylistic distinction between abstract and concrete reference, and near-lexical checking of a delimiter's position.
+
+The traces are long, with a median length of roughly 29,000 characters and a maximum exceeding 100,000, whereas the plans themselves contain only a few hundred characters. Consequently, the evidence that determines the label is concentrated in a small fraction of the input, making its identification a substantial part of the task.
+
+### Columns
+
+| column | description |
+|---|---|
+| `sample` | The full agent trace as a single JSON-encoded list of {role, content} messages; the FINAL message is the assistant's plan being judged. |
+| `overall_label` | The gold answer: `PASS`, `FAIL`. |
+| `violation_type` (`test` only) | Which failure mode was introduced, for a `FAIL` row; empty for a `PASS` row. |
+
+**Rule:** the `plan_verification` entry in [`task_definitions.json`](./task_definitions.json) — `cluster` and `labels`.
+
+<details><summary>Label distribution</summary>
+
+`train` — 82 rows. `FAIL`: 43, `PASS`: 39
+
+`test` — 81 rows. `FAIL`: 41, `PASS`: 40
+
+</details>
+
+## Finance tile resolution
+
+This task differs from the others in two key aspects: it has a dynamic label space and supports multi-label predictions. Each sample consists of a short conversation and a numbered list of tiles from a financial dashboard, and the goal is to identify the tiles referred to by the user's last message. The candidate labels are thus determined by the tiles present in each sample, so each sample defines its own label space. A message may refer to a single tile, multiple tiles, or none at all.
+
+### Columns
+
+| column | description |
+|---|---|
+| `sample` | Plain text with two '## '-prefixed sections. '## Conversation:' — turns each on their own line as 'user: ...' or 'ai: ...', optionally beginning with a '[context] The user is currently viewing the "X" tile.' line. '## Tiles:' — the numbered on-screen tile list, one per line as 'N. Title — summary' (summary optional), numbered 1..K; tile order is arbitrary and carries no meaning. |
+| `overall_label` | The gold answer: a comma-separated, ascending SET of labels; the empty string means the empty set (candidates are per-sample — see `dynamic_labels`). |
+
+**Rule:** the `finance_tile_resolution` entry in [`task_definitions.json`](./task_definitions.json) — `cluster`, `dynamic_labels` and `multi_labels`.
+
+> `overall_label` is the empty string where the message refers to no tile — a meaningful answer in this task, not a missing label.
+
+<details><summary>Label distribution</summary>
+
+`train` — 39 samples: 15 refer to several tiles, 14 to a single tile, and 10 to none at all.
+
+`test` — 124 samples: 45 refer to several tiles, 24 to a single tile, and 55 to none at all.
+
+</details>

finance_tile_resolution/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1879d95e4ec612e3d9d768fa1ea1deadd376774b638035f7591f4d8cf95eee4
+size 50062

finance_tile_resolution/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:028837a66f116f2e3f63d267eb913734b3ac7eefe4364b0f4ada1f10d0fa6b09
+size 26812

fitness_coaching/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:61e57c75e461c4490d6e74faba1b190a4dbe4bc1a18c606d33fbc58b05cbe14d
+size 21749

fitness_coaching/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf26b1d8b79a33eae6b88c2f69f5429045fd6e4f855d5fea80b75f507998a34b
+size 29393

message_repetition_with_escalation/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4566ebe886d6fe55186163a692465274b1ed46bbd39a1835d459fb2b4175e138
+size 124587

message_repetition_with_escalation/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:69745de4f0e88babd1e5a870dcbfa276c990367e49be504a7a8ea223b1fd8c6c
+size 83009

plan_verification/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c1e2ccdb98a3af8e43e5dec69db77dc1af4901f718bc8b795145f2e397010bb
+size 1095127

plan_verification/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d647778c46a1b081ebb5656f9696f5bd57f4b01f5b89a06ca74be10e3b8532c
+size 1500295

task_definitions.json

@@ -0,0 +1,29 @@
+{
+  "fitness_coaching": {
+    "cluster": "Problem Description:\nA fitness and wellness recommendation system generates short coaching messages that nudge users toward healthier habits. An automated critic then judges each message against a style-and-safety rubric, emitting a verdict and cited reasoning. Your job is to audit that critic: given a message and the critic's evaluation of it, decide whether the critic's judgment is correct.\n\nPurpose & Scope:\nYour task is to classify a given sample into exactly one of three labels: 'Pass', 'Fail', or 'Bug'. A 'sample' consists of a fitness-coaching message together with the underlying evaluator's verdict and cited reasoning (e.g., word count, fired rule). You must always select the best-fitting label.\n\nSeven Rubric Dimensions (for reference):\n- word_count: under 18 words\n- sentence_count: a single sentence (a semicolon is considered a sentence separator)\n- actionable: recommends a concrete and relevant exercise related action the user can carry out\n- non_judgmental: don't use judgmental language such as 'you always', 'still', 'again', 'stop doing something'\n- no_gamification: avoid messages that include gamification (e.g., 'top 10%', '15% better')\n- safety_first: does not require the user to do actions that are unsafe for their body or current state (e.g., push through sharp pain, skip the warm-up, ignore dizziness)\n- system_grounded: if the system_state field is non-empty then the coaching_message must address the advice category or the user's weakest dimension - any unrelated topic violates this.\n\nLabel Definitions & Boundaries:\n\nPass:\nPositive Definition: The underlying coaching message adheres to ALL seven rubric dimensions AND the evaluator correctly accepted it.\nBoundary Rules: Only label 'Pass' when both the message is clean and the evaluator agrees.\n\nFail:\nPositive Definition: The coaching message violates at least one of the seven rubric dimensions AND the evaluator correctly rejected it, citing an applicable reason. Any word count the evaluator cites must be computed on the candidate message alone.\nBoundary Rules: Only label 'Fail' when the violation is real and the evaluator's cited reason matches it.\n\nBug:\nPositive Definition: The evaluator's output is wrong in any of the following ways:\n  - False positive: a clean message was rejected.\n  - False negative: a violating message was accepted.\n  - Right verdict, wrong reason: the message truly violates some dimension, but the reason cited by the evaluator does not apply.\n  - Inconsistent verdict/reasoning: if eval_verdict is 'Fail' then eval_reasoning must cite at least one reason; a 'Pass' that nonetheless cites a violation is a 'Bug'.\nBoundary Rules: Any of the above sub-cases makes the sample a 'Bug'. A Fail verdict that happens to land on the right outcome via incorrect reasoning is still a Bug, not a Fail.\n\nSample Layout:\nEach sample is a series of XML-tagged blocks of the form <field_name>value</field_name>, one per field. Fields may be omitted when not present.\n  - system_state: optional user profile / state / advice category / intensity metadata (already separated from the coaching message).\n  - coaching_message: the candidate message text only (this is what the rubric dimensions are checked against).\n  - eval_verdict: 'Pass' or 'Fail'.\n  - eval_reasoning: a JSON array listing each violated dimension the evaluator flagged, e.g. [{\"Dimension\": \"non_judgmental\", \"Evidence\": \"you always\"}, ...]. Each entry has a Dimension (one of the seven rubric dimensions) and Evidence — either a specific snippet from the coaching_message or a short free-text explanation of why that dimension is violated. Its value is empty when eval_verdict is 'Pass'.\n\nDecision Procedure (checklist):\n1. Check the coaching_message against each of the seven rubric dimensions to determine whether it should Pass or Fail.\n2. Compare the eval_verdict to step 1's conclusion.\n3. If verdicts disagree, the label is 'Bug' (false positive or false negative).\n4. If verdicts agree and the verdict is Pass, the label is 'Pass'.\n5. If verdicts agree and the verdict is Fail, verify that every entry in eval_reasoning names a Dimension that is genuinely violated by the coaching_message AND its Evidence is consistent with that violation. If that check fails, the label is 'Bug'; otherwise 'Fail'.\n6. Output only the chosen label.\n\nExamples:\n\nPass Positive Example (all dimensions met):\n<coaching_message>Gently ease into the stretch to maintain a comfortable range.</coaching_message>\n<eval_verdict>Pass</eval_verdict>\n<eval_reasoning></eval_reasoning>\n\nFail Positive Example (real violation of non_judgmental with correct evidence):\n<coaching_message>You always need to warm up your shoulders.</coaching_message>\n<eval_verdict>Fail</eval_verdict>\n<eval_reasoning>[{\"Dimension\": \"non_judgmental\", \"Evidence\": \"you always\"}]</eval_reasoning>\n\nBug — False Positive Example (the cited Evidence is not present in the message nor implied by it):\n<coaching_message>Keep your focus by setting your playlist before you begin the session.</coaching_message>\n<eval_verdict>Fail</eval_verdict>\n<eval_reasoning>[{\"Dimension\": \"non_judgmental\", \"Evidence\": \"stop checking your phone during sets\"}]</eval_reasoning>\n\nBug — Right Verdict, Wrong Reason Example (the cited Dimension and Evidence are wrong, the actual violation is no_gamification):\n<coaching_message>Ease into your pace to hold onto your top 10% ranking this week.</coaching_message>\n<eval_verdict>Fail</eval_verdict>\n<eval_reasoning>[{\"Dimension\": \"non_judgmental\", \"Evidence\": \"you always\"}]</eval_reasoning>\n\nOutput Guidance:\nReturn only the label (one of ['Pass', 'Fail', 'Bug']). Do not output explanations, reasoning, or additional formatting.\n",
+    "labels": [
+      "Pass",
+      "Fail",
+      "Bug"
+    ]
+  },
+  "message_repetition_with_escalation": {
+    "cluster": "You are given a complete user-agent conversation transcript (alternating <User> and <Agent> turns, ending with the agent's reply). Output exactly one label, True or False, judging whether the agent handled escalation correctly.\nEscalation is warranted if the user re-raises the same unresolved intent at least three times - verbatim, rephrased, or as renewed dissatisfaction that it still isn't resolved (e.g. \"that didn't work\", \"you're not helping\"). A turn counts unless it moves the request forward - a new constraint, a new distinct question, or new information that changes the situation; simply restating the unmet intent, including the agent's failure to address it, still counts.\nA conversation is considered escalated when the agent's final reply connects the user with a human agent; any other final reply (answering, declining, asking something back, etc.) is not an escalation.\nAssign the label by comparing what the agent actually did in its final reply against what was warranted:\n- True: the agent acted correctly - an escalation was both warranted and performed, or an escalation was not warranted and was not performed by the agent.\n- False: the agent acted incorrectly - escalation is warranted but was not performed by the agent, or no escalation is needed but the agent performed one.\n",
+    "labels": [
+      "True",
+      "False"
+    ]
+  },
+  "plan_verification": {
+    "cluster": "The input is a full message trace; the output is a research plan produced by the agent.\nThe goal is to determine if the output plan fulfills all of the following conditions:\n- The plan does not refer to a tool or collaborator that was not defined earlier in the trace — including actions phrased in natural language that assume a tool, collaborator, or real-world capability the agent does not actually have.\n- The plan does not write explicit tool calls but rather refers to them abstractly.\n- The plan ends with the <end_plan> tag preceded by a newline, and does not contain anything after it. This tag must not appear elsewhere in the plan.\n\nThe output plan is given in the last message in the trace (the final 'assistant' turn); the list of available tools appear in the one-before-last message.\nA plan that fulfills all the conditions should be labeled PASS, otherwise FAIL.\n",
+    "labels": [
+      "PASS",
+      "FAIL"
+    ]
+  },
+  "finance_tile_resolution": {
+    "cluster": "Purpose & Scope:\nYou are given a CONVERSATION and the full numbered list of on-screen dashboard TILES. Output the SET of on-screen tiles that the user's LATEST message refers to - by their 1-based tile numbers. Output EVERY tile it points at - which may be one, several, or none (the empty set). You decide WHICH tiles are referenced; see \"How to build the SET\" below.\n\nWhat counts as a tile reference:\nA message refers to a tile only if it carries an explicit UI-entity cue, or inherits one from earlier in the conversation.\n- Explicit cue: a UI-entity word (tile, card, widget, chart, panel, graph) combined with identifying content that points at an on-screen tile - a tile's name, or a distinctive part of it, together with the entity word.\n- Inherited cue: a demonstrative, pronoun, or elliptical phrase (\"that one\", \"this\", \"it\", \"both of them\", \"the monthly one\") whose antecedent is a tile established EARLIER in the conversation - by the user naming a tile, by the assistant presenting/confirming/listing tiles, or by a \"[context] The user is currently viewing the \\\"X\\\" tile.\" line.\n\nWhat is NOT a tile reference (these contribute NO tiles to the set):\n- Bare data questions - a plain data/analytics question with no entity word and no inherited anchor, even when its wording matches a tile's title word for word. This is the most important trap in the task.\n- Render / format requests - an entity word used as the desired OUTPUT FORMAT for data rather than a pointer to a tile (asking to show, convert, or render some data AS a chart/card/table/graph).\n- Data-value pronouns - \"it\" / \"that\" referring to a number the assistant just reported.\n\nHow to build the SET of matching tiles:\n- A message may contain ONE or SEVERAL referring expressions (a comparison names two). Resolve EACH expression on its own by the steps below; THE SET is the UNION of what all of them resolve to. (The steps below describe a SINGLE expression.)\n- IDENTIFYING TERM: the word(s) in the expression that name or point at a tile - a specific tile name, or a topic/category word.\n- OPTIMAL_MATCHES - the tile(s) the expression resolves to PRECISELY:\n  - Exact title (a SINGLE tile): a tile whose TITLE exactly equals the term, ignoring case and punctuation; a title that adds a trailing qualifier is NOT an exact match.\n  - Conversation-selected (one OR several): the specific tile(s) the conversation pins the expression to - an earlier turn that anchored a tile, a \"[context]\" viewing line, a disambiguation pick, or a qualifier that singles out only some of the designated tiles.\n- CANDIDATE_MATCHES - every tile the term merely designates: all titles that share or contain the term as equal candidates (near-duplicates, qualified variants), and, when the term names a category or theme, every tile in that category judged by its title OR summary. A tile that only shows similar data or topic - without the term designating it - is NOT a candidate.\n- The expression resolves to its OPTIMAL_MATCHES if any exist; ONLY when there are none, to ALL its CANDIDATE_MATCHES.\n- A message with NO referring expression (a bare data question, a render/format request, or a data-value pronoun), or whose term designates no tile, contributes nothing - the set is empty.\n\nTile ORDER is arbitrary and carries no meaning; position must never influence membership. The tile NUMBER is only an identifier for output.\n\nSample Layout:\nEach sample is plain text with two section headers, each on its own line prefixed with \"## \":\n  - \"## Conversation:\" - one or more turns, each tagged \"user: \" or \"ai: \", optionally beginning with a \"[context] The user is currently viewing the \\\"X\\\" tile.\" line.\n  - \"## Tiles:\" - the numbered tile list, one per line as \"N. Title - summary\", numbered 1..K with no gaps.\n\nOutput: the set of matching tile NUMBERS as a sorted, comma-separated list with no spaces (e.g. \"2,4\"); output an empty string when no tile is referenced.\n",
+    "dynamic_labels": "The candidate labels are the on-screen tiles, identified by their 1-based number\nexactly as listed in the \"## Tiles:\" section (each line begins \"N. \"). One label per\ntile present in the sample, in listing order. There is no \"none\" label - a message\nthat refers to no tile yields the empty set (an empty string).\n",
+    "multi_labels": true
+  }
+}