@graffiticode/l0175 0.2.0

package/spec/data/examples.gc

@@ -0,0 +1,84 @@
+// Comments
+
+| This is a comment
+let x = 10 ..
+
+// Basic variable declarations
+let x = 42..
+let greeting = "hello"..
+let flag = 1..
+
+// Lists
+let empty = []..
+let numbers = [1, 2, 3, 4, 5]..
+let mixed = [1, "two", [3, 4]]..
+
+// Records
+let point = {x: 10, y: 20}..
+let person = {name: "Alice", age: 30, hobbies: ["coding", "reading"]}..
+
+// Lambda expressions
+let identity = <x: x>..
+let add2 = <a b: add a b>..
+let double = <x: add x x>..
+let map = <fn arr: <i: fn arr[i]>>..
+
+// Function application
+let added = add2 3 4..
+let doubled = double 21..
+let mapped = map (double) numbers..
+
+// Composition
+let compose = <f g x: f g x>..
+let addThenDouble = compose (double) (add2)..
+let result2 = addThenDouble 5 7
+
+// Pattern matching (commented in grammar but showing syntax)
+case x of
+  0: "zero"
+  1: "one"
+  _: "many"
+end
+
+// Conditionals
+let max = <x y:
+  if gt x y
+  then x
+  else y
+>..
+
+// Recursive functions
+let factorial = <n:
+  case n of
+  1: 1
+  _: mul n factorial sub n 1
+>..
+
+// Higher order functions
+let filter = <pred arr:
+  case arr of
+    []: []
+    [x, rest]:
+      if (pred x)
+      then concat [x] (filter pred rest)
+      else filter pred rest
+  end
+> ..
+
+let reduce = <f acc xs:
+  case xs of
+    []: acc
+    [x, rest]: reduce f (f acc x) rest
+  end
+> ..
+
+// Real-world examples
+let sum = reduce plus 0 [1 2 3 4]  | yields 10
+
+let shoppingCart = [
+  {name: "Book", price: 10, quantity: 2},
+  {name: "Pen", price: 1, quantity: 5},
+  {name: "Notebook", price: 5, quantity: 1}
+]
+
+let total = calculateTotal shoppingCart

package/spec/data/examples_with_explanations.md

@@ -0,0 +1,124 @@
+<!-- SPDX-License-Identifier: CC-BY-4.0 -->
+# Graffiticode Examples with Explanations
+
+Graffiticode is a functional language with minimal no infix syntax. Here are examples demonstrating core language features:
+
+## Basic Declarations
+
+```gc
+let x = 42..
+```
+Binds the value `42` to the variable `x`.
+
+## Data Structures
+
+### Lists
+
+```gc
+let emptyList = []..
+let numbers = [1 2 3 4 5]..
+let nested = [1 [2 3] 4]..
+```
+Lists can contain any values including other lists. Comma separators are optional. Access elements using index notation: `nth 0 numbers` returns `1`.
+
+### Records
+
+```gc
+let point = {x: 10, y: 20}
+let person = {
+  name: "Alice"
+  age: 30
+  address: {
+    street: "123 Main St"
+    city: "Anytown"
+  }
+}
+```
+Records are key-value structures. Comma separators are optional. Access using dot notation: `get person "name"` returns `"Alice"`.
+
+## Functions
+
+### Lambda Expressions
+
+```gc
+let identity = <x: x>..
+let add2 = <a b: add a b>..
+let double = <x: add x x>..
+```
+Functions are defined using the `<parameters: body>` syntax.
+
+### Function Application
+
+```gc
+let sum = add2 3 4..   // Returns 7
+let twice = double 5..   // Returns 10
+```
+Functions are applied by listing arguments after the function name.
+
+## Higher-Order Functions
+
+```gc
+let map = <fn arr: <i: fn nth i arr>>..
+let filter = <pred arr: <i: if pred arr[i] then arr[i] else []>>..
+let reduce = <fn acc arr: if isEmpty arr then acc else reduce (fn) fn acc hd arr tl arr>..
+
+let doubled = map (double) [1, 2, 3]   // Returns [2, 4, 6]
+let evens = filter (<x: eq mod x 2 0>) [1, 2, 3, 4, 5]   // Returns [2, 4]
+let sum = reduce (add2) 0 [1, 2, 3, 4]   // Returns 10
+```
+Functions that take other functions as arguments or return functions. Wrap function
+arguments in parens to avoid eager evaluation.
+
+## Conditional Logic
+
+```gc
+let max = <a b: if gt a b then a else b>
+let abs = <x: if lt x 0 then -x else x>
+```
+The if-then-else expressions `if condition then trueValue else falseValue` is used for conditionals.
+
+## Recursion
+
+```gc
+let factorial = <n: if le n 1 then 1 else mul n factorial sub n 1>
+let fibonacci = <n: if le n 1 then n else add fibonacci sub n 1 fibonacci sub n 2>
+```
+Functions can call themselves to create recursive algorithms.
+
+## Composition
+
+```gc
+let compose = <f g: f g>..
+let addThenDouble = compose (double) (add)..
+let result = addThenDouble 5 7..   // double(add(5, 7)) = double(12) = 24
+```
+Functions can be composed to create new functions.
+
+## Real-World Example: Data Processing
+
+```gc
+let products = [
+  {id: 1, name: "Laptop", price: 1200, stock: 5},
+  {id: 2, name: "Phone", price: 800, stock: 10},
+  {id: 3, name: "Tablet", price: 500, stock: 7},
+  {id: 4, name: "Headphones", price: 100, stock: 15}
+]..
+
+let inStock = <item: get item "stock" > 0>..
+let applyDiscount = <item discount: {
+  id: item.id
+  name: item.name
+  price: mul get item "price" sub 1 discount
+  stock: get item "stock"
+}>..
+
+let calculateTotal = <items:
+  reduce (<item total: add total get item "price">) 0 items
+>..
+
+// Filter in-stock items, apply 10% discount, calculate total
+let availableItems = filter (inStock) products..
+let discountedItems = map (<item: applyDiscount item 0.1>) availableItems..
+let total = calculateTotal discountedItems..
+```
+A more complex example showing how to process a collection of products.

package/spec/data/training_examples.json

@@ -0,0 +1,122 @@
+[
+  {
+    "description": "Program structure",
+    "code": "42..",
+    "explanation": "Evaluates to the value 42. `..` is the program terminator.",
+    "expected_output": "42"
+  },
+  {
+    "description": "Basic let declaration",
+    "code": "let x = 42..",
+    "explanation": "Binds the value 42 to the variable x. `..` is the declaration terminator.",
+    "expected_output": "x = 42"
+  },
+  {
+    "description": "String declaration",
+    "code": "let greeting = \"hello world\"..",
+    "explanation": "Binds the string \"hello world\" to the variable greeting",
+    "expected_output": "greeting = \"hello world\""
+  },
+  {
+    "description": "List creation",
+    "code": "[1, 2, 3, 4, 5]",
+    "explanation": "Creates a list of integers",
+    "expected_output": "numbers = [1, 2, 3, 4, 5]"
+  },
+  {
+    "description": "List creation",
+    "code": "let numbers = [1, 2, 3, 4, 5]..",
+    "explanation": "Creates a list of integers and binds it to the variable numbers",
+    "expected_output": "numbers = [1, 2, 3, 4, 5]"
+  },
+  {
+    "description": "Record creation",
+    "code": "let person = {name: \"Alice\", age: 30}..",
+    "explanation": "Creates a record with two fields and binds it to the variable person",
+    "expected_output": "person = {name: \"Alice\", age: 30}"
+  },
+  {
+    "description": "Simple lambda expression",
+    "code": "let double = <x: add x x>..",
+    "explanation": "Creates a function that doubles its input and binds it to the variable double",
+    "expected_output": "double = <function>"
+  },
+  {
+    "description": "Function application",
+    "code": "let result = double 21..",
+    "explanation": "Applies the double function to the value 21 and binds the result to the variable result",
+    "expected_output": "result = 42"
+  },
+  {
+    "description": "Multi-parameter lambda",
+    "code": "let sum = <a b: add a b>",
+    "explanation": "Creates a function that adds two values and binds it to the variable sum",
+    "expected_output": "sum = <function>"
+  },
+  {
+    "description": "Multi-parameter function application",
+    "code": "let val = sum 3 4..",
+    "explanation": "Applies the sum function to the values 3 and 4 and binds the result to the variable val",
+    "expected_output": "val = 7"
+  },
+  {
+    "description": "Higher-order function - map implementation",
+    "code": "let map = <fn arr: <i: fn arr[i]>>..",
+    "explanation": "Creates a higher-order function that applies a function to each element of an array",
+    "expected_output": "map = <function>"
+  },
+  {
+    "description": "Using higher-order function",
+    "code": "let doubled = map (double) [1, 2, 3]..",
+    "explanation": "Applies the double function to each element in the array [1, 2, 3]. Function name double is in parens to control function application.",
+    "expected_output": "doubled = [2, 4, 6]"
+  },
+  {
+    "description": "List indexing",
+    "code": "let first = nth numbers 0..",
+    "explanation": "Accesses the first element of the numbers list",
+    "expected_output": "first = 1"
+  },
+  {
+    "description": "Record field access",
+    "code": "let name = get person \"name\"..",
+    "explanation": "Accesses the name field of the person record",
+    "expected_output": "name = \"Alice\""
+  },
+  {
+    "description": "Conditional expression",
+    "code": "let max = <a b: if gt a b then a else b>..",
+    "explanation": "Creates a function that returns the maximum of two values",
+    "expected_output": "max = <function>"
+  },
+  {
+    "description": "Using conditional",
+    "code": "let larger = max 10 20..",
+    "explanation": "Applies the max function to the values 10 and 20",
+    "expected_output": "larger = 20"
+  },
+  {
+    "description": "Recursive function",
+    "code": "let factorial = <n: if le n 1 then 1 else mul n factorial sub n 1>..",
+    "explanation": "Creates a recursive function that calculates the factorial of a number",
+    "expected_output": "factorial = <function>"
+  },
+  {
+    "description": "Using recursive function",
+    "code": "let fact5 = factorial 5..",
+    "explanation": "Calculates the factorial of 5",
+    "expected_output": "fact5 = 120"
+  },
+  {
+    "description": "Function composition",
+    "code": "let compose = <f g x: f g x>..\nlet addThenDouble = compose (double) (add)..\nlet result = addThenDouble 5 7..",
+    "explanation": "Creates a function that composes two functions, then uses it to first add 5 and 7, then double the result",
+    "expected_output": "result = 24"
+  },
+  {
+    "description": "Complex data processing",
+    "code": "let products = [\n  {id: 1, name: \"Laptop\", price: 1200, stock: 5},\n  {id: 2, name: \"Phone\", price: 800, stock: 10},\n  {id: 3, name: \"Tablet\", price: 500, stock: 0}\n]..\n\nlet inStock = <item: gt get item \"stock\" 0>..\nlet availableItems = filter (inStock) products",
+    "explanation": "Filters a list of products to only include those that are in stock",
+    "expected_output": "availableItems = [\n  {id: 1, name: \"Laptop\", price: 1200, stock: 5},\n  {id: 2, name: \"Phone\", price: 800, stock: 10}\n]"
+  }
+]

package/spec/docs.md

@@ -0,0 +1,102 @@
+<!-- SPDX-License-Identifier: CC-BY-4.0 -->
+# L0175 User Manual
+
+_Revised: 2026-06-18_
+
+**Introduction**
+
+*Graffiticode* is a collection of domain languages for creating task-specific web apps.
+**L0175** composes 5th-grade English Language Arts assessment items conforming to the
+Smarter Balanced specification ELA · Grade 5 · Claim 1 (Reading), for learning targets **T4**
+(Reasoning & Evidence, literary), **T11** (Reasoning & Evidence, informational), **T9**
+(Central Ideas, informational), **T8** (Key Details, informational), and **T10** (Word Meanings,
+informational). Targets are **different skills**: T4/T11 ask students to infer or conclude and
+justify with evidence; T9 asks them to determine the main idea, the key details that build it, or
+summarize; T8 **gives** the inference and asks them to select the supporting evidence; T10 asks
+for the meaning of a targeted word in context.
+
+One language serves **multiple learning targets**, chosen by a required top-level `target`:
+`c1-t4` (literary, RL), `c1-t11` (informational, RI), `c1-t9` (informational, RI-1/RI-2),
+`c1-t8` (informational, RI-1/RI-7), or `c1-t10` (informational, RI-4/L-4). It is
+**item-first**: a program declares its `target`, then authors the `outcome`s (questions) first —
+each with a unique `id`, a `focus` correct claim (a **list** on `multi-select`), and an explicit
+`stem` — then the supported and distractor `claim`s (each distractor `targets` the question(s) it
+foils) and the evidence `source`s for one passage. The compiler *composes* each outcome from its
+`focus` and the foils that target it, assembling a finished item (EBSR, Hot Text, Short Text,
+Multiple Choice, or Multi-Select).
+
+### Overview
+
+The program
+
+```
+target c1-t4
+passage "The Tide Pool"
+type literary
+lines [ "Mara crouched at the edge of the tide pool, ignoring the picnic behind her." ]
+claims [ claim id "c1" status supported dimension character subject "Mara"
+  text "Mara is more interested in the tide pool than in the picnic." cites ["e1"] {}
+  claim id "c2" status distractor error-type misreads-detail targets ["q1"]
+  text "Mara is angry at her brother." rationale "Silence is absorption, not anger." cites ["e1"] {} ]
+evidence [ source id "e1" line 1 status directly-supports supports ["c1"] {} ]
+outcomes [ outcome id "q1" type ebsr dimension character subject "Mara" standard rl-1 focus "c1"
+  stem "Which of these inferences about Mara is supported by the passage?"
+  stem-b "Which sentence(s) from the passage best support your answer in Part A?" {} ]
+{}..
+```
+
+composes a two-part EBSR item and renders it as an answerable form with a Student / Review
+toggle.
+
+### Vocabulary
+
+| Form | Arity | Example | Description |
+| ---- | :---: | ------- | ----------- |
+| **target** | 2 | `target c1-t11` | Required, top level; selects the learning-target profile (`c1-t4` / `c1-t11` / `c1-t9` / `c1-t8` / `c1-t10`) |
+| **passage** | 2 | `passage "Title"` | Sets the passage heading; chains with `type` and `lines` |
+| **type** | 2 | `type literary` | Passage type (`literary` / `informational`) or, on an outcome, the item type |
+| **lines** | 2 | `lines [ "..." "..." ]` | Passage paragraphs (one entry per source paragraph), auto-numbered from 1 — preserve the request's paragraph breaks; don't merge into one block. Hot Text selects at the sentence level automatically, so split by paragraph (not by sentence) for every task model |
+| **claims** | 2 | `claims [ claim ... {} ]` | The candidate inference statements |
+| **claim** | 1 | `claim id "c1" status supported ... {}` | One inference candidate (supported or distractor) |
+| **evidence** | 2 | `evidence [ source ... {} ]` | The evidence sources |
+| **source** | 1 | `source id "e1" line 1 status directly-supports ... {}` | One passage line tagged by support role |
+| **outcomes** | 2 | `outcomes [ outcome ... {} ]` | The intended items (authored first) |
+| **outcome** | 1 | `outcome id "q1" type ebsr dimension character focus "c1" stem "..." ... {}` | One question to compose |
+| **rubric** | 2 | `rubric [ band ... {} ]` | Short-text scoring bands (on an outcome) |
+| **band** | 1 | `band score 2 descriptor "..." {}` | One rubric row |
+| **title** | 2 | `title "..."` | Optional assessment title (top level) |
+| **grade** | 2 | `grade 5` | Optional reading-level target (top level); defaults to the guideline/target's grade |
+
+Attribute functions (arity-2, merge one key into the element's record):
+
+- **top level** — `target` (required: `c1-t4` | `c1-t11` | `c1-t9` | `c1-t8` | `c1-t10`), `title` (optional), `grade` (optional reading-level target; defaults to the target's grade), `words` (c1-t10 only — a list of `word`s)
+- **word / meaning** (c1-t10) — `word` has `id`, `text`, `line`/`quote`, `meanings`; `meaning` has `id`, `text`, `status` (`correct` | `distractor`), `error-type`* + `rationale`* on distractors
+- **identity / refs** — `id`, `cites` (claim→evidence ids), `supports` (evidence→claim ids), `focus` (outcome→correct claim id, or a list on `multi-select`), `targets` (distractor→outcome ids)
+- **claim** — `status`, `dimension`, `text`, `error-type`*, `rationale`*, `targets`*, `plausibility` (0–1 distractor temptingness override), `subject`, `standard`, `dok`
+- **evidence** — `status`, `line` (or `quote`), `supports`, `rationale`
+- **outcome / stem** — `id`†, `type`†, `dimension`†, `focus`†, `stem`† (Part A / single-question / prompt, from `stems.md`), `stem-b` (Part B, required on EBSR), `subject`, `standard`, `dok`, `rubric` (short-text)
+- **rubric band** — `score`, `descriptor`
+
+\* required on distractor claims.  † required on every outcome. See `spec.md` for the full per-function reference.
+
+### Enumerations
+
+- `target`: `c1-t4` (literary, R&E), `c1-t11` (informational, R&E), `c1-t9` (informational, Central Ideas), `c1-t8` (informational, Key Details), `c1-t10` (informational, Word Meanings)
+- item `type`: `ebsr`, `hot-text`, `short-text`, `multiple-choice`, `multi-select` (allowed set per target — T4/T11: ebsr/hot-text/short-text · T9: multiple-choice/multi-select/ebsr/hot-text/short-text · T8: multiple-choice/multi-select/hot-text · T10: multiple-choice/multi-select/hot-text)
+- `dimension` (c1-t4): `character`, `setting`, `event`, `point-of-view`, `theme`, `topic`, `narrators-feelings`, `character-relationship`
+- `dimension` (c1-t11): `relationships-interactions`, `author-use-of-information`, `point-of-view`, `purpose`, `authors-opinion`
+- `dimension` (c1-t9): `central-idea`, `key-detail`, `summary` · (c1-t8): `supporting-evidence` · (c1-t10): `word-meaning`
+- claim `status`: `supported`, `distractor` · source `status`: `directly-supports`, `supports-wrong-claim`, `irrelevant` · meaning `status` (c1-t10): `correct`, `distractor`
+- `error-type` (c1-t4 / c1-t11): `misreads-detail`, `erroneous-inference`, `faulty-reasoning` · (c1-t9): `too-narrow`, `too-broad`, `misreads-detail`, `insignificant` · (c1-t8): none (non-supporting sources) · (c1-t10): `other-meaning`, `misinterprets`, `wrong-context`
+- `standard` (c1-t4): `rl-1`, `rl-3`, `rl-6`, `rl-9` · (c1-t11): `ri-1`, `ri-3`, `ri-6`, `ri-7`, `ri-8`, `ri-9` · (c1-t9): `ri-1`, `ri-2` · (c1-t8): `ri-1`, `ri-7` · (c1-t10): `ri-4`, `l-4`, `l-4a`, `l-4b`, `l-4c`, `l-5c`
+- `dok`: `r-dok1`, `r-dok2`, `r-dok3` (R&E → r-dok3; T9 → r-dok2, written summary r-dok3; T8 & T10 → r-dok2)
+
+### Grade-appropriate reading level
+
+Author the passage **and** every claim, option, and rationale at the grade the guideline targets
+(Grade 5 for `c1-t4` / `c1-t11`; override with a top-level `grade <n>` when the user asks for
+another grade). Keep sentences short and mostly simple/compound (≈ `2·grade + 2` words on
+average), vocabulary concrete and high-frequency, and the inference grounded in **specific
+details from the text** rather than abstract literary or rhetorical analysis — DOK 3 is strategic
+reasoning *within* grade-level text, not harder text. The compiler estimates the passage's
+reading level and emits a warning when it reads above the target grade.

package/spec/examples.md

@@ -0,0 +1,91 @@
+<!-- SPDX-License-Identifier: CC-BY-4.0 -->
+# L0175 RAG Training Examples
+
+_Revised: 2026-06-24_
+
+Natural-language prompts for training a RAG model on L0175 — composing 5th-grade ELA
+assessment items (Smarter Balanced · Grade 5 · Claim 1) for learning targets **T4**
+(`target c1-t4`, Reasoning & Evidence, literary), **T11** (`target c1-t11`, Reasoning & Evidence,
+informational), **T9** (`target c1-t9`, Central Ideas, informational), **T8** (`target c1-t8`,
+Key Details, informational), and **T10** (`target c1-t10`, Word Meanings, informational). Each
+program declares its `target` first. Categories 1–6 below are literary (T4); Category 7 is
+informational R&E (T11); Category 8 is Central Ideas (T9); Category 9 is Key Details (T8);
+Category 10 is Word Meanings (T10).
+
+## Category 1: EBSR items (two-part selected response)
+
+1. Write an EBSR item about the main character's motivation in a story about a girl at a tide pool.
+2. Compose a two-part item: Part A asks what can be inferred about the narrator's feelings; Part B asks for the supporting line.
+3. Make an EBSR item about the setting and how it shapes the mood of the scene.
+4. Build an EBSR item about an event and why the character reacts the way she does.
+5. Write an EBSR item about the relationship between two characters, standard rl-3.
+6. Compose an EBSR item about the author's point of view, standard rl-6.
+7. Make an EBSR item about the theme of the passage.
+
+## Category 2: Hot Text items (select text)
+
+8. Make a hot-text item where students click the statement that best describes the character, then click the supporting sentences.
+9. Compose a hot-text item where Part B asks students to highlight every sentence that shows the character's focus.
+10. Write a hot-text item about the narrator's feelings toward another character.
+
+## Category 3: Short Text items (constructed response)
+
+11. Write a short-text item asking what inference can be made about the character, with evidence.
+12. Compose a short-text constructed-response item about the theme, hand-scored 0–2.
+13. Make a short-text item about how the setting affects the character, with a custom rubric.
+
+## Category 4: Authoring the inference graph
+
+14. Add a supported claim, that the character cares more about the tide pool than the picnic, and point question q1's focus at it.
+15. Add a second supported claim about the brother and build a separate question q2 around it.
+16. Tag line 1 and line 3 as directly supporting the main inference.
+17. Mark line 2 as evidence that supports a wrong claim, tied to both the correct claim and the 'anger' distractor.
+18. Mark the last two lines as irrelevant so they can serve as Part B foils.
+
+## Category 5: Distractors by error type
+
+19. Add a misreads-detail distractor for question q1 that takes the character's silence as anger.
+20. Add an erroneous-inference distractor for q1 that the character dislikes being outdoors.
+21. Add a faulty-reasoning distractor for q1 that mistakes the character's whisper for fear.
+22. Give each distractor a rationale explaining the student error it targets, and tag it with the question id(s) it foils.
+
+## Category 6: Item-first composition
+
+23. Compose the questions first: write an EBSR question, a short-text question, and a hot-text question, each with its stem from the guideline catalog, then author foils targeting each.
+24. Compose one question per inference dimension the passage supports, then author a targeted foil set for each.
+25. Set a question's focus to a specific correct claim and write its stem, then author the distractors that target it.
+
+## Category 7: Informational items (target c1-t11)
+
+26. From an informational article about the history of bridge design, write an EBSR item about the relationships between the successive designs (dimension relationships-interactions, standard ri-3).
+27. Make an item about how the author uses evidence to support a point in a science article (dimension author-use-of-information, standard ri-8).
+28. Compose an EBSR item about the author's point of view in an informational passage about city planning (dimension point-of-view, standard ri-6).
+29. Write a short-text item asking what conclusion can be drawn about the author's opinion of renewable energy, with key evidence (dimension authors-opinion).
+30. Make a hot-text item about the author's purpose in an informational passage (dimension purpose).
+
+## Category 8: Central Ideas items (target c1-t9)
+
+A DIFFERENT skill from Reasoning & Evidence — the main idea, the key details that build it, and summary (DOK 2; standards ri-1+ri-2). Distractors are usually TRUE statements that just aren't central: too-narrow (a supporting detail), too-broad (an overgeneralization), insignificant (a minor detail), or misreads-detail.
+
+31. From an informational article about honeybees, write a multiple-choice item asking which sentence best states the main idea (dimension central-idea). Make the distractors a true supporting detail (too-narrow), an overgeneralization (too-broad), and a misread (misreads-detail).
+32. Make a multi-select item: choose the two sentences that should be included in a summary of the passage (dimension summary); `focus` lists the two correct claims, distractors are insignificant or too-broad statements.
+33. Compose an EBSR item where Part A asks for the main idea and Part B asks which detail best supports it (dimension central-idea, standard ri-2).
+34. Write a short-text item: "Determine the main idea of the passage. Explain using key details…" (dimension central-idea, DOK r-dok3).
+35. Write a multiple-choice "missing key detail" item: present a short summary in the stem and ask which key detail is missing; the focus claim is the missing detail.
+
+## Category 9: Key Details items (target c1-t8)
+
+A DIFFERENT model — the inference/conclusion is GIVEN in the stem and the student selects the supporting EVIDENCE (DOK 1–2; standards ri-1+ri-7; dimension supporting-evidence). Author ONE supported claim = the given inference (its `focus`), state it in the stem, and author `source`s as the options: directly-supports = correct evidence (with a `quote`), supports-wrong-claim/irrelevant = distractor evidence. No distractor claims.
+
+36. From an informational article about Roman aqueducts, write a multiple-choice item that states the conclusion "aqueducts brought water to distant cities" and asks which detail from the passage best supports it (dimension supporting-evidence).
+37. Make a multi-select item: which two details best support the stated conclusion? Select two answers (two directly-supports sources are the correct set).
+38. Make a single-part hot-text item: state the inference, then have students click the sentence(s) in the passage that support it (dimension supporting-evidence).
+
+## Category 10: Word Meanings items (target c1-t10)
+
+A DIFFERENT model — the question asks for the MEANING of a targeted word/phrase in context, so the options are meanings (DOK 1–2; standard ri-4 + the L-4 family). Author a top-level `words` list: a `word` (the targeted word, with line/quote for context) holding `meanings` — `status correct` (the answer) + `status distractor` (error-type other-meaning/misinterprets/wrong-context + rationale). The outcome's `focus` names the word; state the word + its sentence in the stem.
+
+39. From an informational article, write a multiple-choice item asking what the word "aqueduct" most likely means as used in the passage (dimension word-meaning, standard l-4a — context). Distractors: another meaning that ignores context (other-meaning), a misread (misinterprets), and a wrong-context meaning.
+40. Make a multi-select item: "What does the word 'channel' most likely mean? Choose two answers." (two correct meanings, dimension word-meaning).
+41. Write a roots/affixes item: ask what the root in a word means, standard l-4b (dimension word-meaning).
+42. Make a click-the-word item (hot-text): "Read the dictionary entry … Click the word in the paragraph that matches this definition." Author the candidate `word`s — the correct one is the outcome's `focus` with the `line` of its paragraph, plus a few distractor candidate words from that same paragraph (`text` only, no `meanings`). The compiler shows the paragraph and makes those authored candidates clickable; the focus word is correct. (Author only the correct word and every content word in the paragraph becomes a choice.) Keep the passage out of the stem.