@bompus/house-rules 0.11.0 → 0.14.0

package/skills/hr-sqlite/scripts/inspect-sqlite.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+"""Read-only inspection of a SQLite database file and, optionally, the source
+that opens it.
+
+    inspect-sqlite.py DATABASE [--source PATH ...] [--quick-check] [--json]
+
+Reports what the file itself records (journal mode, page and freelist counts,
+planner statistics, FTS tables, WAL size) plus the filesystem it sits on. It
+never writes to the database. SQLite may create an empty `-shm` file beside a
+WAL database that no process has open.
+
+Connection settings such as busy_timeout, synchronous, foreign_keys and
+cache_size are not stored in the file, so no database inspection can show what
+an application sets. `--source` is a text scan: for each mention of
+journal_mode it reports whether a busy_timeout mention comes earlier in the
+same file. It does not establish run order or which connection each belongs
+to. Treat those lines as places to read, not verdicts. A source path that cannot
+be read is listed as not scanned and the exit status is 2.
+"""
+import argparse
+import json
+import os
+import pathlib
+import re
+import sqlite3
+import sys
+
+NETWORK_FILESYSTEMS = {"9p", "drvfs", "cifs", "smb3", "smbfs", "nfs", "nfs4", "fuse.sshfs", "virtiofs"}
+SHADOW_SUFFIXES = ("_data", "_idx", "_content", "_docsize", "_config", "_segments", "_segdir", "_stat", "_node", "_parent", "_rowid")
+SOURCE_SUFFIXES = {".py", ".js", ".mjs", ".cjs", ".ts", ".tsx", ".rs", ".go", ".rb", ".java", ".kt", ".cs", ".c", ".cc", ".cpp", ".swift", ".php", ".sql"}
+
+
+def mount_for(path):
+    """Return (mount point, filesystem type, options) for the longest mount prefix."""
+    try:
+        with open("/proc/self/mountinfo", encoding="utf-8", errors="replace") as handle:
+            lines = handle.read().splitlines()
+    except OSError:
+        return None
+    real = os.path.realpath(path)
+    best = None
+    for line in lines:
+        left, _, right = line.partition(" - ")
+        fields = left.split()
+        if len(fields) < 6 or len(right.split()) < 3:
+            continue
+        point = fields[4].replace("\\040", " ")
+        if real == point or real.startswith(point.rstrip("/") + "/") or point == "/":
+            if best is None or len(point) > len(best[0]):
+                kind, _, super_options = right.split()[:3]
+                best = (point, kind, ",".join([fields[5], super_options]))
+    return best
+
+
+def scan_source(paths):
+    """For each file that mentions journal_mode, note where busy_timeout appears.
+
+    Returns (findings, errors). A path that cannot be read is an error, so a
+    failed scan never looks like a scan that found nothing.
+    """
+    findings = []
+    errors = []
+    files = []
+
+    def walk_error(error):
+        errors.append({"file": str(error.filename), "error": error.strerror or str(error)})
+
+    for entry in paths:
+        if os.path.isdir(entry):
+            for root, dirs, names in os.walk(entry, onerror=walk_error):
+                dirs[:] = [d for d in dirs if d not in {".git", "node_modules", ".venv", "target", "dist"}]
+                files.extend(
+                    os.path.join(root, n) for n in names if os.path.splitext(n)[1] in SOURCE_SUFFIXES
+                )
+        else:
+            files.append(entry)
+    for file in sorted(files):
+        try:
+            with open(file, encoding="utf-8", errors="replace") as handle:
+                lines = handle.read().splitlines()
+        except OSError as error:
+            errors.append({"file": file, "error": error.strerror or str(error)})
+            continue
+        journals = [i + 1 for i, l in enumerate(lines) if re.search(r"journal_mode", l, re.I)]
+        timeouts = [i + 1 for i, l in enumerate(lines) if re.search(r"busy_timeout|busyTimeout|set_busy_timeout", l, re.I)]
+        for journal in journals:
+            earlier = [t for t in timeouts if t < journal]
+            if earlier:
+                status = "busy_timeout at line %d comes before journal_mode at line %d" % (earlier[-1], journal)
+            elif timeouts:
+                status = "journal_mode at line %d comes before busy_timeout at line %d" % (journal, timeouts[0])
+            else:
+                status = "journal_mode at line %d; no busy_timeout in this file" % journal
+            findings.append({"file": file, "line": journal, "status": status, "ok": bool(earlier)})
+    return findings, errors
+
+
+def inspect(path, quick_check=False):
+    result = {"path": os.path.abspath(path)}
+    size = os.path.getsize(path)
+    result["fileBytes"] = size
+    uri = pathlib.Path(result["path"]).as_uri() + "?mode=ro"
+    connection = sqlite3.connect(uri, uri=True, timeout=2)
+    try:
+        connection.execute("PRAGMA busy_timeout = 2000")
+
+        def pragma(name):
+            row = connection.execute("PRAGMA " + name).fetchone()
+            return row[0] if row else None
+
+        result["library"] = {"version": sqlite3.sqlite_version}
+        options = [r[0] for r in connection.execute("PRAGMA compile_options")]
+        result["library"]["memstatusDisabled"] = "DEFAULT_MEMSTATUS=0" in options
+        result["library"]["threadsafe"] = next((o for o in options if o.startswith("THREADSAFE")), None)
+        result["journalMode"] = pragma("journal_mode")
+        result["pageSize"] = pragma("page_size")
+        result["pageCount"] = pragma("page_count")
+        result["freelistCount"] = pragma("freelist_count")
+        result["autoVacuum"] = pragma("auto_vacuum")
+        result["userVersion"] = pragma("user_version")
+        result["encoding"] = pragma("encoding")
+        names = connection.execute(
+            "SELECT name, sql FROM sqlite_master WHERE type = 'table' ORDER BY name"
+        ).fetchall()
+        tables = [n for n, _ in names if not n.startswith("sqlite_")]
+        virtual = {n: s for n, s in names if s and s.upper().startswith("CREATE VIRTUAL TABLE")}
+        shadow = {n for table in virtual for n in tables if n in {table + s for s in SHADOW_SUFFIXES}}
+        plain = [n for n in tables if n not in virtual and n not in shadow]
+        result["tables"] = len(plain)
+        result["indexes"] = connection.execute(
+            "SELECT count(*) FROM sqlite_master WHERE type = 'index' AND name NOT LIKE 'sqlite_%'"
+        ).fetchone()[0]
+        result["virtualTables"] = {
+            n: (re.search(r"USING\s+(\w+)", s, re.I) or [None, "unknown"])[1].lower()
+            for n, s in virtual.items()
+        }
+        has_stat = any(n == "sqlite_stat1" for n, _ in names)
+        analyzed = set()
+        if has_stat:
+            analyzed = {r[0] for r in connection.execute("SELECT DISTINCT tbl FROM sqlite_stat1")}
+        result["statistics"] = {
+            "sqliteStat1": has_stat,
+            "rows": connection.execute("SELECT count(*) FROM sqlite_stat1").fetchone()[0] if has_stat else 0,
+            "tablesWithoutStatistics": [n for n in plain if n not in analyzed],
+        }
+        if quick_check:
+            result["quickCheck"] = [r[0] for r in connection.execute("PRAGMA quick_check(10)")]
+    finally:
+        connection.close()
+    for suffix, key in (("-wal", "walBytes"), ("-shm", "shmBytes")):
+        side = result["path"] + suffix
+        result[key] = os.path.getsize(side) if os.path.exists(side) else None
+    mount = mount_for(result["path"])
+    if mount:
+        point, kind, options = mount
+        result["filesystem"] = {"mount": point, "type": kind, "options": options}
+    else:
+        result["filesystem"] = None
+    return result
+
+
+def notes(result):
+    out = []
+    if result["journalMode"] != "wal":
+        out.append("journal_mode is %s, not wal; in a rollback journal a writer's commit waits for readers and blocks new ones while it commits" % result["journalMode"])
+    stats = result["statistics"]
+    if not stats["sqliteStat1"]:
+        out.append("no sqlite_stat1: the planner has no statistics; run PRAGMA optimize at a time you choose (the first run on a large file can take over a minute and hold the write lock)")
+    elif stats["tablesWithoutStatistics"]:
+        out.append("tables with no statistics rows: " + ", ".join(stats["tablesWithoutStatistics"][:8]))
+    pages = result["pageCount"] or 0
+    if pages and result["freelistCount"] and result["freelistCount"] / pages > 0.2:
+        out.append("more than 20%% of pages are free (%d of %d); the file is larger than its content" % (result["freelistCount"], pages))
+    if result["walBytes"] and result["walBytes"] > result["fileBytes"]:
+        out.append("the WAL file is larger than the database; look for a long-running reader or a blocked checkpoint")
+    fs = result["filesystem"]
+    if fs:
+        if fs["type"] in NETWORK_FILESYSTEMS:
+            out.append("filesystem %s: WAL needs shared memory on one host and does not work reliably here" % fs["type"])
+        if re.search(r"(^|,)discard(,|$)", fs["options"]):
+            out.append("mounted with online discard; this stalled fsync on one host (see the evidence), so check fsync latency")
+    if "quickCheck" in result and result["quickCheck"] != ["ok"]:
+        out.append("quick_check reported: " + "; ".join(result["quickCheck"][:3]))
+    return out
+
+
+def render(result, source, source_errors=()):
+    lines = ["database: %s" % result["path"]]
+    lines.append("size: %d bytes; %s pages of %s bytes; %s free" % (
+        result["fileBytes"], result["pageCount"], result["pageSize"], result["freelistCount"]))
+    lines.append("journal_mode: %s; auto_vacuum: %s; user_version: %s; encoding: %s" % (
+        result["journalMode"], result["autoVacuum"], result["userVersion"], result["encoding"]))
+    lines.append("tables: %d; indexes: %d; virtual tables: %s" % (
+        result["tables"], result["indexes"],
+        ", ".join("%s (%s)" % kv for kv in result["virtualTables"].items()) or "none"))
+    stats = result["statistics"]
+    lines.append("statistics: sqlite_stat1 %s, %d rows" % ("present" if stats["sqliteStat1"] else "absent", stats["rows"]))
+    lines.append("wal file: %s; shm file: %s" % (result["walBytes"], result["shmBytes"]))
+    fs = result["filesystem"]
+    lines.append("filesystem: %s" % ("%s at %s (%s)" % (fs["type"], fs["mount"], fs["options"]) if fs else "not available on this platform"))
+    lines.append("inspector library: SQLite %s, %s" % (result["library"]["version"], result["library"]["threadsafe"]))
+    lines.append("not in the file: busy_timeout, synchronous, foreign_keys, cache_size, mmap_size, temp_store; read the code that opens the connection")
+    for note in notes(result):
+        lines.append("note: " + note)
+    if source is not None:
+        lines.append("source scan (journal_mode mentions): %d" % len(source))
+        for item in source:
+            lines.append("  %s: %s%s" % (item["file"], item["status"], "" if item["ok"] else "  <- read this"))
+        for item in source_errors:
+            lines.append("  not scanned: %s (%s)" % (item["file"], item["error"]))
+    return "\n".join(lines)
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    parser.add_argument("database")
+    parser.add_argument("--source", nargs="+", metavar="PATH", help="files or directories to scan for busy_timeout order")
+    parser.add_argument("--quick-check", action="store_true", help="also run PRAGMA quick_check (reads the whole file)")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args(argv)
+    if not os.path.isfile(args.database):
+        print("error: not a file: %s" % args.database, file=sys.stderr)
+        return 2
+    try:
+        result = inspect(args.database, args.quick_check)
+    except (sqlite3.Error, OSError) as error:
+        print("error: %s" % error, file=sys.stderr)
+        return 2
+    source, source_errors = scan_source(args.source) if args.source else (None, [])
+    if args.json:
+        payload = dict(result)
+        payload["notes"] = notes(result)
+        if source is not None:
+            payload["source"] = source
+            payload["sourceErrors"] = source_errors
+        print(json.dumps(payload, indent=2, sort_keys=True))
+    else:
+        print(render(result, source, source_errors))
+    for item in source_errors:
+        print("error: could not scan %s: %s" % (item["file"], item["error"]), file=sys.stderr)
+    return 2 if source_errors else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/hr-stock-ui-audit/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: hr-stock-ui-audit
-description: Find template-default styling in frontend code that nobody chose for this product (stock violet accents, purple-to-blue gradients, one stock font, emoji icons, glow and blur effects), triage each hit in context, and report or fix the real ones as the request asks. Use when asked to audit or remove generic or AI-looking styling in existing UI. It does not set a visual direction.
+description: Find template-default styling nobody chose for this product (stock violet accents, purple-to-blue gradients, one stock font, emoji icons, glow and blur effects), triage each hit in context, and report or fix the real ones. Use when asked to audit or remove generic or AI-looking styling in existing UI. It does not set a visual direction.
 ---
 
 # Stock UI audit

package/skills/hr-test-audit/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aaron Queen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/hr-test-audit/NOTICE.md

@@ -0,0 +1,67 @@
+# Source notices
+
+This notice accompanies the hr-test-audit bundle when copied on its own.
+Each source below is published under the MIT License. The licence text at the
+end applies to each of them, with the copyright line shown for that source.
+
+## obra/superpowers
+
+Source: https://github.com/obra/superpowers (compared at revision `8ca22db`)
+
+- `SKILL.md`: cites `writing-good-tests.md`.
+
+Copyright (c) 2025 Jesse Vincent
+
+## addyosmani/agent-skills
+
+Source: https://github.com/addyosmani/agent-skills (compared at revision `9d0c60d`)
+
+- `scripts/floor-guard.ts`: adapted from constraint-driven-development.
+
+Copyright (c) 2025 Addy Osmani
+
+## openclaw/openclaw
+
+Source: https://github.com/openclaw/openclaw (linked at revision `65f1e4d`, compared at `1fda703`)
+
+- `SKILL.md`: the authoring gate, junk patterns, retention bar and evidence
+  fields are adapted from `.agents/skills/test-audit/`.
+
+Copyright (c) 2026 OpenClaw Foundation
+
+## no-human-ai/no_human
+
+Source: https://github.com/no-human-ai/no_human (compared at revision `9b50bf6`)
+
+- `SKILL.md`: the rule that weakening a test counts as removing it is adapted
+  from its tamper guard.
+
+Copyright (c) 2026 Eyal Golan
+
+## omkamal/pypict-claude-skill
+
+Source: https://github.com/omkamal/pypict-claude-skill (compared at revision `fbda212`)
+
+- `SKILL.md`: the pairwise-coverage guidance is adapted from this skill.
+
+Copyright (c) 2025 pypict-claude-skill contributors
+
+## MIT License text
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/hr-usage-report/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: hr-usage-report
+description: Measure where Claude Code, Codex and OpenCode usage went by provider, model and role, and chart model comparisons as HTML. Use for quota or cost questions and to show a model or role recommendation visually.
+---
+
+# Usage report
+
+Answer quota and model-role questions from measured usage and published
+evidence, then show the result as charts and tables. Run the scripts from this
+skill's directory with Bun.
+
+## 1. Measure where usage went
+
+```bash
+bun scripts/usage-by-model.ts --days 7 [--providers claude,codex,opencode] [--claude-projects <dir,dir>] [--prices <api.json>] [--json]
+```
+
+It reads Claude Code transcripts (`projects` under `~/.claude` and under every
+other `~/.claude_*` or `~/.claude-*` configuration directory, so sessions run
+with a separate `CLAUDE_CONFIG_DIR` count; `--claude-projects` replaces that
+list), Codex rollouts
+(`~/.codex/sessions`) and the OpenCode database, all read-only and local. It
+prices each request at [models.dev](https://models.dev) list rates, including
+long-context tiers, and splits usage by provider, model and role: main session,
+subagent, advisor. Without `--prices` it downloads `https://models.dev/api.json`;
+that request carries no local data. Use `--since <ISO>` for a fixed start.
+
+Read the output beside the provider's live quota readings:
+
+- **Shares, not dollars.** List price stands in for subscription quota; no
+  provider publishes the conversion. Say so in the report.
+- **Cache reads.** When cache reads dominate a row's cost, context length, not
+  the model's output, drives usage. Compare the main-request context median
+  with the session-start median: the gap is conversation growth; the start is
+  fixed overhead (system prompt, rules, tool schemas).
+- **Advisor rows.** Each advisor call re-reads the whole transcript uncached at
+  the advisor's rates; a few calls can outweigh many main turns.
+- **Cross-provider work.** The same table shows what the author's sessions and
+  another vendor's reviewer each cost.
+- **Unpriced models.** The summary lists models models.dev has no price for;
+  report them rather than dropping them.
+
+## 2. Pick evidence by question
+
+| Question                              | Evidence                                                             | Read                                                                |
+| ------------------------------------- | -------------------------------------------------------------------- | ------------------------------------------------------------------- |
+| Quality per dollar for implementation | Agentic coding boards that publish effort, harness and cost per task | Score against cost at every effort; cost per solved task            |
+| Review and bug finding                | Bug-finding boards with run counts per row                           | The effort curve; treat single runs as noisy                        |
+| Raw speed                             | Output tokens per second                                             | Generation speed only                                               |
+| Task speed                            | Boards that time whole tasks                                         | Time to finish; a model that generates faster can still take longer |
+| Fit for your own work                 | A known-answer trial on your own tasks (`hr-benchmarking`)           | Correctness and model time per task shape                           |
+
+Compare models at the same effort and harness, or say they differ. A vendor
+table that sets one model's top effort against another's lower effort is not a
+matched comparison. Keep token speed and task time in separate charts; never
+infer one from the other.
+
+## 3. Render the report
+
+Write a data file, then:
+
+```bash
+bun scripts/render-report.ts <data.json> <out.html>
+```
+
+The page is self-contained, follows the host's theme variables when it is
+embedded, and falls back to a dark surface. `assets/example-report.json` uses
+every section type.
+
+The data file declares `series` once, so each model keeps one color across
+every chart in the report: up to three colored series with slots 0 to 2, and at
+most one `"reference": true` series drawn dashed and neutral. The renderer
+rejects a fourth colored series because no fourth hue passes the color-vision
+check on the dark surface against the other three. Compare more models in a
+second report file.
+
+Section types:
+
+- `curve`: points with `x`, `y`, `label`, `tip` per series; `xLog`, domains,
+  ticks and axis affixes. Use for score against cost across efforts.
+- `ladder`: `categories` (usually efforts) and `values` per series, `null` for a
+  missing row, optional `notes` such as run counts.
+- `bars`: `rows` of `label`, `key`, `value`, optional `display` and `tip`.
+- `pair`: two sections side by side, such as token speed beside task time.
+- `table`: `columns` and `rows`; a cell may be `{ "text", "verdict": "yes" | "maybe" | "no" }`;
+  `numeric` lists right-aligned column indexes.
+
+End with one verdict table per model or role: role, key evidence with numbers,
+verdict. Name the evidence date in the title, and apply any model or effort
+limits the user has set before recommending a configuration.

package/skills/hr-usage-report/agents/openai.yaml

@@ -0,0 +1,2 @@
+interface:
+  display_name: "HR: Usage report"

package/skills/hr-usage-report/assets/example-report.json

@@ -0,0 +1,125 @@
+{
+  "title": "Example: three models across effort levels (illustrative data)",
+  "series": {
+    "small": { "name": "Model S", "slot": 0 },
+    "mid": { "name": "Model M", "slot": 1 },
+    "large": { "name": "Model L", "slot": 2 },
+    "previous": { "name": "Model L (previous)", "reference": true }
+  },
+  "sections": [
+    {
+      "type": "curve",
+      "title": "Score against cost per task, every effort level",
+      "sub": "Illustrative values. Each line runs low to max on a log cost axis.",
+      "xLog": true,
+      "xDomain": [0.05, 20],
+      "yDomain": [20, 60],
+      "xTicks": [0.1, 0.3, 1, 3, 10],
+      "xPrefix": "$",
+      "yTicks": [20, 30, 40, 50, 60],
+      "ySuffix": "%",
+      "xLabel": "cost per task (log)",
+      "series": [
+        {
+          "key": "small",
+          "points": [
+            { "label": "low", "x": 0.08, "y": 28, "tip": "28% · $0.08/task" },
+            { "label": "medium", "x": 0.2, "y": 34, "tip": "34% · $0.20/task" },
+            { "label": "max", "x": 1, "y": 45, "tip": "45% · $1.00/task" }
+          ]
+        },
+        {
+          "key": "mid",
+          "points": [
+            { "label": "low", "x": 0.5, "y": 35, "tip": "35% · $0.50/task" },
+            { "label": "medium", "x": 0.8, "y": 40, "tip": "40% · $0.80/task" },
+            { "label": "max", "x": 8, "y": 54, "tip": "54% · $8.00/task" }
+          ]
+        },
+        {
+          "key": "large",
+          "points": [
+            { "label": "low", "x": 1.2, "y": 44, "tip": "44% · $1.20/task" },
+            { "label": "medium", "x": 3, "y": 52, "tip": "52% · $3.00/task" },
+            { "label": "max", "x": 12, "y": 57, "tip": "57% · $12.00/task" }
+          ]
+        },
+        {
+          "key": "previous",
+          "points": [
+            { "label": "low", "x": 5, "y": 43, "tip": "43% · $5.00/task" },
+            { "label": "max", "x": 16, "y": 50, "tip": "50% · $16.00/task" }
+          ]
+        }
+      ]
+    },
+    {
+      "type": "ladder",
+      "title": "Review: bugs found per effort level",
+      "sub": "Illustrative values; notes carry run counts.",
+      "categories": ["low", "medium", "high", "max"],
+      "yDomain": [0, 50],
+      "yTicks": [0, 25, 50],
+      "series": [
+        {
+          "key": "small",
+          "values": [10, 12, 16, null],
+          "notes": ["1 run", "1 run", "2 runs", "no row"]
+        },
+        {
+          "key": "mid",
+          "values": [18, 23, 34, 45],
+          "notes": ["3 runs", "3 runs", "3 runs", "3 runs"]
+        },
+        {
+          "key": "large",
+          "values": [22, 30, 32, 41],
+          "notes": ["3 runs", "3 runs", "3 runs", "3 runs"]
+        }
+      ]
+    },
+    {
+      "type": "pair",
+      "items": [
+        {
+          "type": "bars",
+          "title": "Generation speed: output tokens/s",
+          "max": 400,
+          "rows": [
+            { "label": "Model S", "key": "small", "value": 380 },
+            { "label": "Model M", "key": "mid", "value": 220 },
+            { "label": "Model L", "key": "large", "value": 125 }
+          ]
+        },
+        {
+          "type": "bars",
+          "title": "Task time: minutes per task",
+          "max": 3,
+          "rows": [
+            { "label": "Model S", "key": "small", "value": 2.6, "display": "2:36" },
+            { "label": "Model M", "key": "mid", "value": 1, "display": "1:00" },
+            { "label": "Model L", "key": "large", "value": 2.1, "display": "2:06" }
+          ]
+        }
+      ]
+    },
+    {
+      "type": "table",
+      "title": "Model S: where it fits",
+      "columns": ["Role", "Key evidence", "Verdict"],
+      "rows": [
+        [
+          "Narrow read-only lookups",
+          "Equal accuracy on known-answer lookups at a fraction of the cost",
+          { "text": "Yes", "verdict": "yes" }
+        ],
+        [
+          "Mechanical edits",
+          "Matches Model M medium at lower cost; untested on your work",
+          { "text": "Try on a named task", "verdict": "maybe" }
+        ],
+        ["Review", "Finds about half of what Model L finds", { "text": "No", "verdict": "no" }]
+      ]
+    }
+  ]
+}