Space: approved N05 benchmark plan, no results (Projektant 768d8104)

benchmarks-contract.js

@@ -0,0 +1,104 @@
+"use strict";
+/* Local, dependency-free checks for the keyword subset used by N05's pinned
+   05ff4733 schema. Not a general Draft2020 implementation. Unknown keywords
+   fail closed. The authoritative schema is benchmarks.schema.json. */
+(() => {
+  const keywords = new Set(["$schema", "$id", "$defs", "$ref", "type", "const", "enum", "properties", "required", "additionalProperties", "items", "pattern", "minLength", "minimum", "maximum", "anyOf", "allOf", "if", "then", "else"]);
+  const own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+  const object = value => value !== null && typeof value === "object" && !Array.isArray(value);
+  function matches(value, rule, root) {
+    for (const key of Object.keys(rule)) if (!keywords.has(key)) throw new Error(`Unsupported schema keyword: ${key}`);
+    if (rule.$ref) {
+      if (!rule.$ref.startsWith("#/")) throw new Error("External schema references are not allowed");
+      let target = root;
+      for (const key of rule.$ref.slice(2).split("/")) {
+        if (!own(target, key)) throw new Error("Unresolved schema reference");
+        target = target[key];
+      }
+      if (!matches(value, target, root)) return false;
+    }
+    if (own(rule, "const") && value !== rule.const) return false;
+    if (rule.enum && !rule.enum.includes(value)) return false;
+    if (rule.type) {
+      const types = Array.isArray(rule.type) ? rule.type : [rule.type];
+      if (!types.some(type => type === "null" ? value === null : type === "array" ? Array.isArray(value) : type === "object" ? object(value) : type === "integer" ? Number.isInteger(value) : type === "number" ? typeof value === "number" && Number.isFinite(value) : typeof value === type)) return false;
+    }
+    if (typeof value === "string") {
+      if (rule.minLength !== undefined && [...value].length < rule.minLength) return false;
+      if (rule.pattern && !new RegExp(rule.pattern).test(value)) return false;
+    }
+    if (typeof value === "number") {
+      if (!Number.isFinite(value)) return false;
+      if (rule.minimum !== undefined && value < rule.minimum) return false;
+      if (rule.maximum !== undefined && value > rule.maximum) return false;
+    }
+    if (Array.isArray(value) && rule.items && !value.every(item => matches(item, rule.items, root))) return false;
+    if (object(value)) {
+      if (rule.required && !rule.required.every(key => own(value, key))) return false;
+      const props = rule.properties || {};
+      for (const key of Object.keys(value)) {
+        if (own(props, key)) {
+          if (!matches(value[key], props[key], root)) return false;
+        } else if (rule.additionalProperties === false) return false;
+      }
+    }
+    if (rule.anyOf && !rule.anyOf.some(part => matches(value, part, root))) return false;
+    if (rule.allOf && !rule.allOf.every(part => matches(value, part, root))) return false;
+    if (rule.if) {
+      const branch = matches(value, rule.if, root) ? rule.then : rule.else;
+      if (branch && !matches(value, branch, root)) return false;
+    }
+    return true;
+  }
+  const key = (...parts) => JSON.stringify(parts);
+  function unique(items, getKey, name) {
+    const map = new Map();
+    for (const item of items) {
+      const id = getKey(item);
+      if (map.has(id)) throw new Error(`Duplicate ${name}: ${id}`);
+      map.set(id, item);
+    }
+    return map;
+  }
+  function validCI(ci) {
+    if (ci !== null && ci.lower > ci.upper) throw new Error("CI lower exceeds upper");
+  }
+  function validate(packet, inventory, schema, inventoryRevision) {
+    if (!matches(packet, schema, schema)) throw new Error("Packet does not match the pinned N05 schema");
+    if (packet.provenance.kind !== "measurement") throw new Error("Contract example is not a measurement");
+    if (packet.provenance.inventory_commit !== inventoryRevision) throw new Error("Inventory revision differs from the displayed protocol");
+    if (![`${inventory.protocol}-panel200`, `${inventory.protocol}-fullB`].includes(packet.protocol_id)) throw new Error("Unknown protocol scale");
+    const models = unique(packet.models, m => m.model_id, "model");
+    const tasks = unique(packet.tasks, t => t.task_id, "task");
+    const plan = new Map(inventory.rows.map(t => [t.id, t]));
+    for (const task of tasks.values()) {
+      const item = plan.get(task.task_id);
+      if (!item || ["task", "family", "language", "split"].some(field => task[field] !== item[field])) throw new Error(`Task metadata differs: ${task.task_id}`);
+    }
+    const observations = unique(packet.observations, o => key(o.task_id, o.model_id, o.protocol_id), "observation");
+    for (const o of observations.values()) {
+      if (!tasks.has(o.task_id) || !models.has(o.model_id) || o.protocol_id !== packet.protocol_id) throw new Error("Unknown task, model or protocol in observation");
+      if ((o.n_selected !== null && o.n_scored > o.n_selected) || (o.n_selected !== null && o.n_population !== null && o.n_selected > o.n_population)) throw new Error("Inconsistent sample counts");
+      validCI(o.ci95);
+    }
+    const contrasts = unique(packet.contrasts, c => key(c.task_id, c.model_id, c.model_ref, c.protocol_id), "contrast");
+    for (const c of contrasts.values()) {
+      if (!tasks.has(c.task_id) || !models.has(c.model_id) || !models.has(c.model_ref) || c.protocol_id !== packet.protocol_id) throw new Error("Unknown key in contrast");
+      validCI(c.ci95);
+      if (c.verdict !== "withheld") {
+        const left = observations.get(key(c.task_id, c.model_id, c.protocol_id));
+        const right = observations.get(key(c.task_id, c.model_ref, c.protocol_id));
+        if (!left || !right || left.state !== "ok" || right.state !== "ok" || left.metric !== right.metric || left.unit !== right.unit || left.higher_is_better !== right.higher_is_better) throw new Error("Accepted contrast lacks comparable observations");
+        if ((c.verdict === "better" || c.verdict === "worse") && c.p_holm > 0.05) throw new Error("Decisive verdict conflicts with the declared Holm rule");
+      }
+    }
+    return {models, tasks, observations, contrasts};
+  }
+  const api = {validate, key,
+    revision: "326c4474393c223c77bb3a3ca6a82e001758d056",
+    inventorySHA: "67a751a0e53800203e6ec63100a9fd777dbc1f899171acee3181cf1cc8ab44b0",
+    schemaSHA: "68a3e5dc934ccf82748d12b26c3a44d7a1f338efaae5b113d22a2960108adc92"
+  };
+  if (typeof module !== "undefined" && module.exports) module.exports = api;
+  else window.N05Contract = api;
+})();

benchmarks-feed.json

@@ -0,0 +1,3 @@
+{
+  "results": null
+}

benchmarks-plan.json

@@ -0,0 +1,869 @@
+{
+  "schema_version": 1,
+  "protocol": "N05-50-v0.2",
+  "counts": {
+    "rows": 50,
+    "PL": 25,
+    "EN": 25
+  },
+  "sources": {
+    "lm_eval_commit": "6d2abda4fd171e68a8789330c4149e37c1ca0bda",
+    "openpl_commit": "21d0ea9cf4fd6153dfff4d84d6ad0aab5488f302",
+    "openpl_about_snapshot": "Ewaluator/bielik/about_space_0d30867d.py"
+  },
+  "selection": {
+    "seed": 20261028,
+    "max_documents_per_task": 200,
+    "unit": "canonical source document; paired versions share membership",
+    "ordering": "SHA256(UTF8(\"20261028|\"+family+\"|\"+source_id)); ties by canonical source bytes",
+    "when": "freeze manifests before model scoring; no prefix limit",
+    "full_protocol_B": "separate full 23-task replication; never compare sample score to published full score",
+    "support_policy": "panel only: five support IDs ranked by SHA256(20261028|family|support|source_id); declared/fallback pool after process_docs; same-split support removed from scored population; record all demo IDs and actual_shots",
+    "context_policy": "panel lm-eval max_length4096 float32 batch1; drop support from end to fit prompt+YAML max_gen_toks; never silently cut query/options; fullB retains independently verified source protocol",
+    "harness_seed_tuple": {
+      "python": 0,
+      "numpy": 1234,
+      "torch": 1234,
+      "fewshot": 1234
+    }
+  },
+  "rows": [
+    {
+      "id": "T01",
+      "task": "blimp_glint",
+      "language": "EN",
+      "family": "blimp",
+      "metric": "accuracy",
+      "instrument": "custom_glint",
+      "split": "train",
+      "rationale": "minimal-pair grammar",
+      "shots": 0
+    },
+    {
+      "id": "T02",
+      "task": "arc_easy_glint",
+      "language": "EN",
+      "family": "arc_easy",
+      "metric": "accuracy",
+      "instrument": "custom_glint",
+      "split": "test",
+      "rationale": "school science",
+      "shots": 0
+    },
+    {
+      "id": "T03",
+      "task": "wikitext2_byte",
+      "language": "EN",
+      "family": "wikitext2",
+      "metric": "byte_perplexity",
+      "instrument": "custom_glint",
+      "split": "test",
+      "rationale": "language modelling",
+      "shots": 0
+    },
+    {
+      "id": "T04",
+      "task": "multiblimp_pl",
+      "language": "PL",
+      "family": "multiblimp",
+      "metric": "accuracy",
+      "instrument": "custom_pl",
+      "split": "pol/data.tsv",
+      "rationale": "Polish grammar",
+      "shots": 0
+    },
+    {
+      "id": "T05",
+      "task": "arc_easy_pl_eu20",
+      "language": "PL",
+      "family": "arc_easy",
+      "metric": "accuracy",
+      "instrument": "custom_pl",
+      "split": "test",
+      "rationale": "paired science EN/PL",
+      "shots": 0
+    },
+    {
+      "id": "T06",
+      "task": "hellaswag",
+      "language": "EN",
+      "family": "hellaswag",
+      "metric": "acc_norm",
+      "instrument": "lm_eval_0.4.8",
+      "split": "validation",
+      "rationale": "commonsense",
+      "shots": 0,
+      "definition": "lm_eval/tasks/hellaswag/hellaswag.yaml"
+    },
+    {
+      "id": "T07",
+      "task": "piqa",
+      "language": "EN",
+      "family": "piqa",
+      "metric": "acc_norm",
+      "instrument": "lm_eval_0.4.8",
+      "split": "validation",
+      "rationale": "physical reasoning",
+      "shots": 0,
+      "definition": "lm_eval/tasks/piqa/piqa.yaml"
+    },
+    {
+      "id": "T08",
+      "task": "arc_challenge",
+      "language": "EN",
+      "family": "arc_challenge",
+      "metric": "acc_norm",
+      "instrument": "lm_eval_0.4.8",
+      "split": "test",
+      "rationale": "science",
+      "shots": 0,
+      "definition": "lm_eval/tasks/arc/arc_challenge.yaml"
+    },
+    {
+      "id": "T09",
+      "task": "winogrande",
+      "language": "EN",
+      "family": "winogrande",
+      "metric": "acc",
+      "instrument": "lm_eval_0.4.8",
+      "split": "validation",
+      "rationale": "coreference",
+      "shots": 0,
+      "definition": "lm_eval/tasks/winogrande/default.yaml"
+    },
+    {
+      "id": "T10",
+      "task": "openbookqa",
+      "language": "EN",
+      "family": "openbookqa",
+      "metric": "acc_norm",
+      "instrument": "lm_eval_0.4.8",
+      "split": "test",
+      "rationale": "science",
+      "shots": 0,
+      "definition": "lm_eval/tasks/openbookqa/openbookqa.yaml"
+    },
+    {
+      "id": "T11",
+      "task": "sciq",
+      "language": "EN",
+      "family": "sciq",
+      "metric": "acc_norm",
+      "instrument": "lm_eval_0.4.8",
+      "split": "test",
+      "rationale": "science with provided support",
+      "shots": 0,
+      "definition": "lm_eval/tasks/sciq/sciq.yaml"
+    },
+    {
+      "id": "T12",
+      "task": "boolq",
+      "language": "EN",
+      "family": "boolq",
+      "metric": "acc",
+      "instrument": "lm_eval_0.4.8",
+      "split": "validation",
+      "rationale": "reading comprehension",
+      "shots": 0,
+      "definition": "lm_eval/tasks/super_glue/boolq/default.yaml"
+    },
+    {
+      "id": "T13",
+      "task": "copa",
+      "language": "EN",
+      "family": "copa",
+      "metric": "acc",
+      "instrument": "lm_eval_0.4.8",
+      "split": "validation",
+      "rationale": "causal reasoning",
+      "shots": 0,
+      "definition": "lm_eval/tasks/super_glue/copa/default.yaml"
+    },
+    {
+      "id": "T14",
+      "task": "cb",
+      "language": "EN",
+      "family": "cb",
+      "metric": "acc",
+      "instrument": "lm_eval_0.4.8",
+      "split": "validation",
+      "rationale": "entailment",
+      "shots": 0,
+      "definition": "lm_eval/tasks/super_glue/cb/default.yaml"
+    },
+    {
+      "id": "T15",
+      "task": "wic",
+      "language": "EN",
+      "family": "wic",
+      "metric": "acc",
+      "instrument": "lm_eval_0.4.8",
+      "split": "validation",
+      "rationale": "word sense",
+      "shots": 0,
+      "definition": "lm_eval/tasks/super_glue/wic/default.yaml"
+    },
+    {
+      "id": "T16",
+      "task": "wsc273",
+      "language": "EN",
+      "family": "wsc273",
+      "metric": "acc",
+      "instrument": "lm_eval_0.4.8",
+      "split": "test",
+      "rationale": "coreference",
+      "shots": 0,
+      "definition": "lm_eval/tasks/wsc273/default.yaml"
+    },
+    {
+      "id": "T17",
+      "task": "sglue_rte",
+      "language": "EN",
+      "family": "sglue_rte",
+      "metric": "acc",
+      "instrument": "lm_eval_0.4.8",
+      "split": "validation",
+      "rationale": "entailment",
+      "shots": 0,
+      "definition": "lm_eval/tasks/super_glue/rte/default.yaml"
+    },
+    {
+      "id": "T18",
+      "task": "anli_r1",
+      "language": "EN",
+      "family": "anli",
+      "metric": "acc",
+      "instrument": "lm_eval_0.4.8",
+      "split": "test_r1",
+      "rationale": "adversarial entailment",
+      "shots": 0,
+      "definition": "lm_eval/tasks/anli/anli_r1.yaml"
+    },
+    {
+      "id": "T19",
+      "task": "anli_r2",
+      "language": "EN",
+      "family": "anli",
+      "metric": "acc",
+      "instrument": "lm_eval_0.4.8",
+      "split": "test_r2",
+      "rationale": "adversarial entailment",
+      "shots": 0,
+      "definition": "lm_eval/tasks/anli/anli_r2.yaml"
+    },
+    {
+      "id": "T20",
+      "task": "anli_r3",
+      "language": "EN",
+      "family": "anli",
+      "metric": "acc",
+      "instrument": "lm_eval_0.4.8",
+      "split": "test_r3",
+      "rationale": "adversarial entailment",
+      "shots": 0,
+      "definition": "lm_eval/tasks/anli/anli_r3.yaml"
+    },
+    {
+      "id": "T21",
+      "task": "swag",
+      "language": "EN",
+      "family": "swag",
+      "metric": "acc_norm",
+      "instrument": "lm_eval_0.4.8",
+      "split": "validation",
+      "rationale": "continuation",
+      "shots": 0,
+      "definition": "lm_eval/tasks/swag/swag.yaml"
+    },
+    {
+      "id": "T22",
+      "task": "lambada_openai",
+      "language": "EN",
+      "family": "lambada_openai",
+      "metric": "acc",
+      "instrument": "lm_eval_0.4.8",
+      "split": "test",
+      "rationale": "last-word completion",
+      "shots": 0,
+      "definition": "lm_eval/tasks/lambada/lambada_openai.yaml"
+    },
+    {
+      "id": "T23",
+      "task": "logiqa",
+      "language": "EN",
+      "family": "logiqa",
+      "metric": "acc_norm",
+      "instrument": "lm_eval_0.4.8",
+      "split": "test",
+      "rationale": "logical reasoning",
+      "shots": 0,
+      "definition": "lm_eval/tasks/logiqa/logiqa.yaml"
+    },
+    {
+      "id": "T24",
+      "task": "mathqa",
+      "language": "EN",
+      "family": "mathqa",
+      "metric": "acc_norm",
+      "instrument": "lm_eval_0.4.8",
+      "split": "test",
+      "rationale": "arithmetic multiple choice",
+      "shots": 0,
+      "definition": "lm_eval/tasks/mathqa/mathqa.yaml"
+    },
+    {
+      "id": "T25",
+      "task": "prost",
+      "language": "EN",
+      "family": "prost",
+      "metric": "acc_norm",
+      "instrument": "lm_eval_0.4.8",
+      "split": "test",
+      "rationale": "physical reasoning",
+      "shots": 0,
+      "definition": "lm_eval/tasks/prost/corypaik_prost.yaml"
+    },
+    {
+      "id": "T26",
+      "task": "qnli",
+      "language": "EN",
+      "family": "qnli",
+      "metric": "acc",
+      "instrument": "lm_eval_0.4.8",
+      "split": "validation",
+      "rationale": "question entailment",
+      "shots": 0,
+      "definition": "lm_eval/tasks/glue/qnli/default.yaml"
+    },
+    {
+      "id": "T27",
+      "task": "sst2",
+      "language": "EN",
+      "family": "sst2",
+      "metric": "acc",
+      "instrument": "lm_eval_0.4.8",
+      "split": "validation",
+      "rationale": "sentiment",
+      "shots": 0,
+      "definition": "lm_eval/tasks/glue/sst2/default.yaml"
+    },
+    {
+      "id": "T28",
+      "task": "polemo2_in",
+      "language": "PL",
+      "family": "polemo2-in",
+      "metric": "exact_match,score-first",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "polemo2-in_g",
+      "random_baseline_percent": 41.6,
+      "dataset_path": "allegro/klej-polemo2-in",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polemo2/polemo2_in.yaml",
+          "sha256": "55f52677240b29b17e212914b24d5a4d461480e39f39af6753108ed1b888b399"
+        }
+      ]
+    },
+    {
+      "id": "T29",
+      "task": "polemo2_in_multiple_choice",
+      "language": "PL",
+      "family": "polemo2-in",
+      "metric": "acc,none",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "polemo2-in_mc",
+      "random_baseline_percent": 41.6,
+      "dataset_path": "allegro/klej-polemo2-in",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polemo2/polemo2_in_mc.yaml",
+          "sha256": "3cf0b8fc1b478a900fc484827b2caf35d3a7c5b249733f9c306ab144ec37c254"
+        }
+      ]
+    },
+    {
+      "id": "T30",
+      "task": "polemo2_out",
+      "language": "PL",
+      "family": "polemo2-out",
+      "metric": "exact_match,score-first",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "polemo2-out_g",
+      "random_baseline_percent": 36.8,
+      "dataset_path": "allegro/klej-polemo2-out",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polemo2/polemo2_in.yaml",
+          "sha256": "55f52677240b29b17e212914b24d5a4d461480e39f39af6753108ed1b888b399"
+        },
+        {
+          "path": "lm_eval/tasks/polemo2/polemo2_out.yaml",
+          "sha256": "e2bd578ebfe3fe5b92ad08caac1220ca1db02958f03697f5e993faab0dc08127"
+        }
+      ]
+    },
+    {
+      "id": "T31",
+      "task": "polemo2_out_multiple_choice",
+      "language": "PL",
+      "family": "polemo2-out",
+      "metric": "acc,none",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "polemo2-out_mc",
+      "random_baseline_percent": 36.8,
+      "dataset_path": "allegro/klej-polemo2-out",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polemo2/polemo2_in_mc.yaml",
+          "sha256": "3cf0b8fc1b478a900fc484827b2caf35d3a7c5b249733f9c306ab144ec37c254"
+        },
+        {
+          "path": "lm_eval/tasks/polemo2/polemo2_out_mc.yaml",
+          "sha256": "634d051e40b1b91ad7ef2f29194c76f280cd404e6a54af8f40f9e6dc956c8057"
+        }
+      ]
+    },
+    {
+      "id": "T32",
+      "task": "polish_8tags_multiple_choice",
+      "language": "PL",
+      "family": "8tags",
+      "metric": "acc,none",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "8tags_mc",
+      "random_baseline_percent": 14.3,
+      "dataset_path": "sdadas/8tags",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_8tags/8tags_mc.yaml",
+          "sha256": "fce252aaf70fc0220ea786c43b1798edc1cfd4e826c60666f040b418be2a39cd"
+        }
+      ]
+    },
+    {
+      "id": "T33",
+      "task": "polish_8tags_regex",
+      "language": "PL",
+      "family": "8tags",
+      "metric": "exact_match,score-first",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "8tags_g",
+      "random_baseline_percent": 14.3,
+      "dataset_path": "sdadas/8tags",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_8tags/8tags_regex.yaml",
+          "sha256": "e389be0939f0c1a9be0e552659c1ea8950b77ca69254ecab4b6ded7c24314371"
+        }
+      ]
+    },
+    {
+      "id": "T34",
+      "task": "polish_belebele_mc",
+      "language": "PL",
+      "family": "belebele",
+      "metric": "acc,none",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "belebele_mc",
+      "random_baseline_percent": 27.9,
+      "dataset_path": "facebook/belebele",
+      "dataset_config": "pol_Latn",
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_belebele/belebele_mc.yaml",
+          "sha256": "eb9ae0c3398424dfda4641bc983ea8497d75d1cfcd11a9cdcbf4e346769d7ccf"
+        }
+      ]
+    },
+    {
+      "id": "T35",
+      "task": "polish_belebele_regex",
+      "language": "PL",
+      "family": "belebele",
+      "metric": "exact_match,score-first",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "belebele_g",
+      "random_baseline_percent": 27.9,
+      "dataset_path": "facebook/belebele",
+      "dataset_config": "pol_Latn",
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_belebele/belebele_regex.yaml",
+          "sha256": "9db37451b44dab22531f273dd690f5cd7b8518d0e4bb6d8d34e6bcc7b2507562"
+        }
+      ]
+    },
+    {
+      "id": "T36",
+      "task": "polish_dyk_multiple_choice",
+      "language": "PL",
+      "family": "dyk",
+      "metric": "f1,none",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "dyk_mc",
+      "random_baseline_percent": 28.9,
+      "dataset_path": "allegro/klej-dyk",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_dyk/dyk_mc.yaml",
+          "sha256": "5ccbe634ee0222ce7f260b5f4932b1f015db6ccdd7f0a1d327d88184bf466f67"
+        }
+      ]
+    },
+    {
+      "id": "T37",
+      "task": "polish_dyk_regex",
+      "language": "PL",
+      "family": "dyk",
+      "metric": "f1,score-first",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "dyk_g",
+      "random_baseline_percent": 28.9,
+      "dataset_path": "allegro/klej-dyk",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_dyk/dyk_regex.yaml",
+          "sha256": "b553c5dcf938d8baf1c1862282e96c21b36c9d65bfffda84856d506ef9fdf6dc"
+        }
+      ]
+    },
+    {
+      "id": "T38",
+      "task": "polish_ppc_multiple_choice",
+      "language": "PL",
+      "family": "ppc",
+      "metric": "acc,none",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "ppc_mc",
+      "random_baseline_percent": 41.9,
+      "dataset_path": "sdadas/ppc",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_ppc/ppc_mc.yaml",
+          "sha256": "fd6a04fbcec596966b0bcc91b7b3451255f94a8fae59c131455af32fac930054"
+        }
+      ]
+    },
+    {
+      "id": "T39",
+      "task": "polish_ppc_regex",
+      "language": "PL",
+      "family": "ppc",
+      "metric": "exact_match,score-first",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "ppc_g",
+      "random_baseline_percent": 41.9,
+      "dataset_path": "sdadas/ppc",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_ppc/ppc_regex.yaml",
+          "sha256": "02f1f211515c2085dc6d69bb6f002af9c3ecb23168f52f54ead81b6bfdde7f5d"
+        }
+      ]
+    },
+    {
+      "id": "T40",
+      "task": "polish_psc_multiple_choice",
+      "language": "PL",
+      "family": "psc",
+      "metric": "f1,none",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "psc_mc",
+      "random_baseline_percent": 46.6,
+      "dataset_path": "allegro/klej-psc",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_psc/psc_mc.yaml",
+          "sha256": "51200832bcdb6752bc1c6cce40884cd853c1494217d3b6f4ae9f2392c859ef31"
+        }
+      ]
+    },
+    {
+      "id": "T41",
+      "task": "polish_psc_regex",
+      "language": "PL",
+      "family": "psc",
+      "metric": "f1,score-first",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "psc_g",
+      "random_baseline_percent": 46.6,
+      "dataset_path": "allegro/klej-psc",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_psc/psc_regex.yaml",
+          "sha256": "c38ba8f17b47ba22a4a0fe02cbd7613cc31445db76013dd8d825f17e9e8b0278"
+        }
+      ]
+    },
+    {
+      "id": "T42",
+      "task": "polish_cbd_multiple_choice",
+      "language": "PL",
+      "family": "cbd",
+      "metric": "f1,none",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "cbd_mc",
+      "random_baseline_percent": 14.9,
+      "dataset_path": "ptaszynski/PolishCyberbullyingDataset",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_cbd/cbd_mc.yaml",
+          "sha256": "acb5162e11544953ff0d63bf16159e9439f9aed945f9d8a1c082531c43d1687b"
+        }
+      ]
+    },
+    {
+      "id": "T43",
+      "task": "polish_cbd_regex",
+      "language": "PL",
+      "family": "cbd",
+      "metric": "f1,score-first",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "cbd_g",
+      "random_baseline_percent": 14.9,
+      "dataset_path": "ptaszynski/PolishCyberbullyingDataset",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_cbd/cbd_regex.yaml",
+          "sha256": "bcb3321bf9538c7e784c6923a176906875fa30da0c77650f9152b6ff01e20b1d"
+        }
+      ]
+    },
+    {
+      "id": "T44",
+      "task": "polish_klej_ner_multiple_choice",
+      "language": "PL",
+      "family": "klej_ner",
+      "metric": "acc,none",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "klej_ner_mc",
+      "random_baseline_percent": 34.3,
+      "dataset_path": "allegro/klej-nkjp-ner",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_klej_ner/klej_ner_mc.yaml",
+          "sha256": "cb2910d8d8e32d5826306c68bd9b2b8d00f14e9988ff889c2024aa5b8076dfe5"
+        }
+      ]
+    },
+    {
+      "id": "T45",
+      "task": "polish_klej_ner_regex",
+      "language": "PL",
+      "family": "klej_ner",
+      "metric": "exact_match,score-first",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "klej_ner_g",
+      "random_baseline_percent": 34.3,
+      "dataset_path": "allegro/klej-nkjp-ner",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_klej_ner/klej_ner_regex.yaml",
+          "sha256": "fab9466e15bb9e4c9e9bcb5d302ee86e19ae908fb7f7a267105663e12d843639"
+        }
+      ]
+    },
+    {
+      "id": "T46",
+      "task": "polish_polqa_reranking_multiple_choice",
+      "language": "PL",
+      "family": "polqa",
+      "metric": "acc,none",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "polqa_reranking_mc",
+      "random_baseline_percent": 53.35588953,
+      "dataset_path": "ipipan/polqa",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_polqa/polqa_reranking.yaml",
+          "sha256": "abc2914e338eb177260fa21e50ddb2a2df32174b43802c634ce173239ef34eda"
+        }
+      ]
+    },
+    {
+      "id": "T47",
+      "task": "polish_polqa_open_book",
+      "language": "PL",
+      "family": "polqa",
+      "metric": "levenshtein,none",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "polqa_open_book_g",
+      "random_baseline_percent": 0.0,
+      "dataset_path": "ipipan/polqa",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_polqa/polqa_open_book.yaml",
+          "sha256": "59dcf0d577382fc0785301308120bb862159b8cccb2b50985a000c1d3b217b20"
+        }
+      ]
+    },
+    {
+      "id": "T48",
+      "task": "polish_polqa_closed_book",
+      "language": "PL",
+      "family": "polqa",
+      "metric": "levenshtein,none",
+      "instrument": "openpl_polish4",
+      "split": "test",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "polqa_closed_book_g",
+      "random_baseline_percent": 0.0,
+      "dataset_path": "ipipan/polqa",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_polqa/polqa_closed_book.yaml",
+          "sha256": "8ed09d3d16daef754a31bb0ab609c268373f3bd11bec3103c73b5c24981da953"
+        }
+      ]
+    },
+    {
+      "id": "T49",
+      "task": "polish_poquad_open_book",
+      "language": "PL",
+      "family": "poquad",
+      "metric": "levenshtein,none",
+      "instrument": "openpl_polish4",
+      "split": "validation",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "poquad_open_book",
+      "random_baseline_percent": 0.0,
+      "dataset_path": "clarin-pl/poquad",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_poquad/poquad_open_book.yaml",
+          "sha256": "c32d349dc6afbcb8b91c7d7f4cab70430e333b4e252016bc378e21e16ac64092"
+        }
+      ]
+    },
+    {
+      "id": "T50",
+      "task": "polish_eq_bench_first_turn",
+      "language": "PL",
+      "family": "eq_bench_first_turn",
+      "metric": "first_eqbench,none",
+      "instrument": "openpl_polish4",
+      "split": "validation",
+      "rationale": "complete official Open PL average; generation/MC variants are correlated protocols, not independent datasets",
+      "shots": 5,
+      "leaderboard_column": "eq_bench_first_turn",
+      "random_baseline_percent": 0.0,
+      "dataset_path": "speakleash/EQ-Bench-PL-first-turn",
+      "dataset_config": null,
+      "dataset_revision_declared": null,
+      "definition_files": [
+        {
+          "path": "lm_eval/tasks/polish_eq_bench/default.yaml",
+          "sha256": "0338e02cc0bac6ee9944bde8d228cf2412df97328a524d3b20515642a15ac5ad"
+        },
+        {
+          "path": "lm_eval/tasks/polish_eq_bench/first_turn.yaml",
+          "sha256": "b53960a2a36fcfdce3a7246f83e57b8f9a6123cb9cf970df68005c6e1fec610c"
+        }
+      ]
+    }
+  ]
+}

benchmarks.css

@@ -0,0 +1,27 @@
+.bench-panel .bench-content{margin-top:20px;min-width:0;overflow-wrap:anywhere}
+.bench-panel .bench-notice{border-left:3px solid var(--acc);padding:12px 16px;background:var(--card);color:var(--soft);max-width:82ch}
+.bench-panel .bench-controls{display:flex;flex-wrap:wrap;align-items:end;gap:12px;margin:20px 0 12px}
+.bench-panel label{display:grid;gap:6px;color:var(--muted);font-size:.88rem}
+.bench-panel input,.bench-panel select,.bench-panel button{font:inherit;background:var(--card);color:var(--fg);border:1px solid var(--line2);border-radius:8px;padding:10px 12px;max-width:100%}
+.bench-panel input{width:260px}
+.bench-panel button{cursor:pointer}
+.bench-panel :focus-visible{outline:2px solid var(--acc);outline-offset:3px}
+.bench-panel .bench-summary{color:var(--soft);font-variant-numeric:tabular-nums;margin:12px 0}
+.bench-panel .bench-explanation{color:var(--muted);font-size:.9rem;max-width:82ch}
+.bench-panel .bench-wrap{overflow:auto;border:1px solid var(--line2);border-radius:12px;max-height:640px;scrollbar-gutter:stable}
+.bench-panel table{min-width:820px;width:100%;border-collapse:separate;border-spacing:0}
+.bench-panel th,.bench-panel td{padding:14px;text-align:left;white-space:normal;min-width:180px;vertical-align:top;border-bottom:1px solid var(--line)}
+.bench-panel thead th{position:sticky;top:0;background:var(--card2);z-index:2;text-transform:none;letter-spacing:normal;font-size:.9rem}
+.bench-panel th:first-child,.bench-panel td:first-child{position:sticky;left:0;width:250px;min-width:220px;background:var(--card);z-index:1}
+.bench-panel thead th:first-child{z-index:3;background:var(--card2)}
+.bench-panel .bench-task{font-weight:650;overflow-wrap:anywhere;text-transform:none;letter-spacing:normal;font-size:.9rem}
+.bench-panel .bench-meta{display:block;color:var(--muted);font-size:.82rem;line-height:1.55;margin-top:6px;overflow-wrap:anywhere}
+.bench-panel .bench-value{display:block;font-size:1.12rem;font-weight:650;font-variant-numeric:tabular-nums}
+.bench-panel .bench-state{display:inline-block;color:var(--muted);font-size:.85rem;margin-top:4px}
+.bench-panel .bench-verdict{display:block;margin:8px 0 0;font-size:.85rem}
+.bench-panel details{margin:10px 0;font-size:.84rem;color:var(--muted)}
+.bench-panel summary{cursor:pointer}
+.bench-panel code{overflow-wrap:anywhere;white-space:normal}
+.bench-panel .bench-provenance{margin-top:18px;color:var(--muted);font-size:.84rem;max-width:85ch}
+.bench-panel [hidden]{display:none!important}
+@media(max-width:640px){.bench-panel .bench-controls{display:grid;grid-template-columns:1fr}.bench-panel input,.bench-panel select,.bench-panel button{width:100%}.bench-panel th,.bench-panel td{padding:12px;min-width:180px}.bench-panel th:first-child,.bench-panel td:first-child{min-width:150px;width:150px}.bench-panel .bench-wrap{max-height:590px}.bench-panel table{min-width:760px}}

benchmarks.js

@@ -0,0 +1,216 @@
+"use strict";
+(() => {
+  const contract = window.N05Contract;
+  const plannedModels = [
+    {model_id:"planned-slayer", repo:"SlayerLab/Slayer1B-1.06"},
+    {model_id:"planned-bielik", repo:"speakleash/Bielik-1.5B-v3"},
+    {model_id:"planned-lfm", repo:"LiquidAI/LFM2.5-1.2B-Base"}
+  ];
+  const modelLabels = new Map(plannedModels.map(m => [m.repo, m.repo.split("/")[1]]));
+  const words = {
+    pl: {
+      search:"Szukaj zadania / rodziny", language:"Język", all:"Wszystkie", clear:"Wyczyść filtry",
+      inventory:"Inwentarz protokołu", shown:"Pokazano", of:"z", rows:"wierszy zadanie × protokół",
+      task:"Zadanie / rodzina", protocol:"Przyrząd / split", planned:"Plan · brak danych w widoku", absent:"Nie dostarczono obserwacji",
+      missingSource:"Źródło wyników nie jest jeszcze podłączone. Pokazuję wyłącznie plan, nie wyniki 50 benchmarków. Historyczne liczby powyżej nie zostały do niego przepisane.",
+      loadError:"Nie udało się wczytać przypiętego kontraktu. Nie pokazuję danych zastępczych.", invalidResults:"Wyniki ukryte — nie udało się odebrać paczki pomiarowej",
+      empty:"Brak zadań pasujących do filtrów.",
+      explanation:"Wartości zachowują własne jednostki. CI95 jest opisowy, nie „po Holmie”. Brak wyniku nie jest zerem; brak istotności nie oznacza remisu. UI nie wylicza werdyktów.",
+      sample:"Plan: min(200, N), WikiText — pełny test. Panel-200 nie jest pełną repliką Open PL. Powiązane warianty nie są niezależnymi korpusami. Shot przy zadaniu jest planem; actual_shots i odcięcia pochodzą z manifestu wykonania. T03 zachowuje wskaźnik kompatybilny z Glint tp^(N/B), nie deklarację dokładnego exp(NLL/B).",
+      planStatus:"Kontrakt zakresu — nie odebrany pakiet uruchomieniowy.", revision:"Rewizja inwentarza", measured:"obserwacji ok", supplied:"obserwacji dostarczonych", noResults:"bez odebranej paczki wyników",
+      ci:"CI95 opisowy", noCI:"Brak CI", against:"względem", review:"Odbiór kontrastu", provenance:"Pochodzenie", weights:"SHA wag", unknown:"nie dostarczono",
+      higher:"więcej ↑", lower:"mniej ↓", counts:"n: populacja / wybrane / ocenione", metrics:"miara", state:"Stan", run:"Bieg", scale:"Protokół / skala",
+      states:{ok:"Pomiar",not_run:"Nie uruchomiono",blocked_access:"Brak dostępu",blocked_runtime:"Blokada środowiska",blocked_security:"Blokada bezpieczeństwa",blocked_judge:"Brak odebranego sędziego",unsupported:"Nieobsługiwane",failed:"Błąd wykonania",skipped:"Pominięte"},
+      verdicts:{withheld:"Werdykt wstrzymany",better:"Lepszy",worse:"Gorszy",inconclusive:"Nierozstrzygnięte — nie remis"}
+    },
+    en: {
+      search:"Search task / family", language:"Language", all:"All", clear:"Clear filters",
+      inventory:"Protocol inventory", shown:"Showing", of:"of", rows:"task × protocol rows",
+      task:"Task / family", protocol:"Instrument / split", planned:"Planned · no data in this view", absent:"Observation not supplied",
+      missingSource:"The result source is not connected yet. This is the plan, not fifty benchmark results. Historical measurements above have not been copied into it.",
+      loadError:"The pinned contract could not be loaded. No substitute data is shown.", invalidResults:"Results hidden — measurement packet could not be accepted",
+      empty:"No tasks match the filters.",
+      explanation:"Values retain their own units. CI95 is descriptive, not “Holm-adjusted”. Missing results are not zero; lack of significance does not imply equivalence. The UI does not compute verdicts.",
+      sample:"Plan: min(200, N); WikiText uses the full test. Panel-200 is not full Open PL replication. Related variants are not independent datasets. A task's shot count is planned; actual_shots and truncation belong to the execution manifest. T03 retains the Glint-compatible tp^(N/B) indicator, not a claim of exact exp(NLL/B).",
+      planStatus:"Scope contract — not an accepted execution package.", revision:"Inventory revision", measured:"ok observations", supplied:"supplied observations", noResults:"no accepted result packet",
+      ci:"Descriptive CI95", noCI:"CI not supplied", against:"versus", review:"Contrast review", provenance:"Provenance", weights:"Weights SHA", unknown:"not supplied",
+      higher:"higher ↑", lower:"lower ↓", counts:"n: population / selected / scored", metrics:"metric", state:"State", run:"Run", scale:"Protocol / scale",
+      states:{ok:"Measured",not_run:"Not run",blocked_access:"Access blocked",blocked_runtime:"Runtime blocked",blocked_security:"Security blocked",blocked_judge:"Judge not accepted",unsupported:"Unsupported",failed:"Execution failed",skipped:"Skipped"},
+      verdicts:{withheld:"Verdict withheld",better:"Better",worse:"Worse",inconclusive:"Inconclusive — not equivalent"}
+    }
+  };
+  function el(tag, text, className) {
+    const node = document.createElement(tag);
+    if (text !== undefined) node.textContent = String(text);
+    if (className) node.className = className;
+    return node;
+  }
+  function option(value, text) { const node = el("option", text); node.value = value; return node; }
+  function label(text, input) { const node = el("label", text); node.append(input); return node; }
+  function modelName(model) { return modelLabels.get(model.repo) || model.repo; }
+  function number(value, locale, unit) {
+    const digits = unit === "percent" ? 2 : unit === "byte_ppl" ? 4 : 6;
+    return new Intl.NumberFormat(locale === "pl" ? "pl-PL" : "en-GB", {maximumFractionDigits:digits}).format(value);
+  }
+  function interval(ci, locale, unit, text) {
+    return ci === null ? text.noCI : `${text.ci}: [${number(ci.lower, locale, unit)}; ${number(ci.upper, locale, unit)}]`;
+  }
+  function detail(title, lines) {
+    const node = el("details");
+    node.append(el("summary", title));
+    for (const line of lines) node.append(el("p", line));
+    return node;
+  }
+  function observationCell(observation, task, model, context, locale, text) {
+    const cell = el("td");
+    if (!observation) {
+      cell.append(el("span", context.packet ? text.absent : text.planned, "bench-state"));
+      return cell;
+    }
+    const o = observation;
+    cell.append(el("span", text.states[o.state], "bench-state"));
+    if (o.state === "ok") {
+      const unit = o.unit === "percent" ? "%" : o.unit === "byte_ppl" ? "byte-PPL" : "score";
+      cell.append(el("span", `${number(o.value, locale, o.unit)} ${unit}`, "bench-value"),
+        el("span", `${text.metrics}: ${o.metric} · ${o.higher_is_better ? text.higher : text.lower}`, "bench-meta"),
+        el("span", interval(o.ci95, locale, o.unit, text), "bench-meta"));
+    }
+    cell.append(el("span", `${text.counts}: ${o.n_population ?? text.unknown} / ${o.n_selected ?? text.unknown} / ${o.n_scored}`, "bench-meta"));
+    for (const contrast of context.index.contrasts.values()) {
+      if (contrast.task_id !== task.id || contrast.model_id !== model.model_id) continue;
+      const ref = context.index.models.get(contrast.model_ref);
+      const heading = `${text.verdicts[contrast.verdict]} ${text.against} ${modelName(ref)}`;
+      cell.append(el("span", heading, "bench-verdict"));
+      if (contrast.verdict !== "withheld") {
+        cell.append(detail(text.review, [
+          `Δ: ${number(contrast.delta, locale, o.unit)}`,
+          interval(contrast.ci95, locale, o.unit, text),
+          `p_raw: ${contrast.p_raw}; p_holm: ${contrast.p_holm}; family_size: ${contrast.family_size}`,
+          `${contrast.review.actor} · artifact_sha256: ${contrast.review.artifact_sha256}`
+        ]));
+      }
+    }
+    cell.append(detail(text.provenance, [
+      `source_id_digest: ${o.source_id_digest ?? text.unknown}`,
+      `results_sha256: ${o.results_sha256 ?? text.unknown}`,
+      `runner_sha256: ${o.runner_sha256 ?? text.unknown}`
+    ]));
+    return cell;
+  }
+  function build(section, context) {
+    const locale = section.dataset.locale;
+    const text = words[locale];
+    const inventory = context.inventory;
+    const models = context.packet && context.packet.models.length ? context.packet.models : plannedModels;
+    const root = section.querySelector(".bench-content");
+    root.removeAttribute("role");
+    root.replaceChildren();
+    const message = context.error ? `${text.invalidResults}: ${context.error}` : context.packet ? `${text.run}: ${context.packet.run_id} · ${text.scale}: ${context.packet.protocol_id}` : text.missingSource;
+    const notice = el("p", message, "bench-notice");
+    const search = el("input");
+    search.type = "search";
+    const language = el("select");
+    language.append(option("all", text.all), option("PL", "PL"), option("EN", "EN"));
+    const clear = el("button", text.clear);
+    clear.type = "button";
+    const controls = el("div", undefined, "bench-controls");
+    controls.append(label(text.search, search), label(text.language, language), clear);
+    const summary = el("p", undefined, "bench-summary");
+    summary.setAttribute("role", "status");
+    summary.setAttribute("aria-live", "polite");
+    const explanation = el("p", text.explanation, "bench-explanation");
+    explanation.id = `bench-note-${locale}`;
+    const wrap = el("div", undefined, "bench-wrap");
+    wrap.tabIndex = 0;
+    wrap.setAttribute("role", "region");
+    wrap.setAttribute("aria-label", text.inventory);
+    const table = el("table");
+    table.setAttribute("aria-labelledby", `bench-title-${locale}`);
+    table.setAttribute("aria-describedby", explanation.id);
+    const head = el("thead");
+    const header = el("tr");
+    for (const name of [text.task, text.protocol]) { const th = el("th", name); th.scope = "col"; header.append(th); }
+    for (const model of models) {
+      const th = el("th", modelName(model));
+      th.scope = "col";
+      if (context.packet && context.index.models.has(model.model_id)) th.append(detail(text.provenance, [
+        `repo: ${model.repo}`, `revision: ${model.revision ?? text.unknown}`, `${text.weights}: ${model.weights_sha256 ?? text.unknown}`
+      ]));
+      header.append(th);
+    }
+    head.append(header);
+    const body = el("tbody");
+    table.append(head, body);
+    wrap.append(table);
+    const empty = el("p", text.empty);
+    const origin = el("div", undefined, "bench-provenance");
+    const planLink = el("a", "N05 · tasks_50_v01.json");
+    planLink.href = "benchmarks-plan.json";
+    const schemaLink = el("a", "N05 · results.schema.json");
+    schemaLink.href = "benchmarks.schema.json";
+    origin.append(el("p", text.planStatus), el("p", text.sample), planLink, el("span", " · "), schemaLink,
+      el("p", `${text.revision}: ${contract.revision}`), el("p", `inventory SHA-256: ${contract.inventorySHA}`));
+    if (context.packet) origin.append(el("p", `packet SHA-256: ${context.packetSHA}`));
+    root.append(notice, controls, summary, explanation, wrap, empty, origin);
+    function render() {
+      const query = search.value.trim().toLocaleLowerCase(locale);
+      const tasks = inventory.rows.filter(task => (language.value === "all" || task.language === language.value) &&
+        `${task.id} ${task.task} ${task.family}`.toLocaleLowerCase(locale).includes(query));
+      const fragment = document.createDocumentFragment();
+      for (const task of tasks) {
+        const row = el("tr");
+        const th = el("th", `${task.id} · ${task.task}`, "bench-task");
+        th.scope = "row";
+        th.append(el("span", `${task.language} · ${task.family}`, "bench-meta"));
+        const procedure = el("td", task.instrument);
+        procedure.append(el("span", `${task.split} · ${locale === "pl" ? "plan" : "planned"}: ${task.shots}-shot`, "bench-meta"), el("span", task.metric, "bench-meta"));
+        row.append(th, procedure);
+        for (const model of models) {
+          const o = context.index && context.index.observations.get(contract.key(task.id, model.model_id, context.packet.protocol_id));
+          row.append(observationCell(o, task, model, context, locale, text));
+        }
+        fragment.append(row);
+      }
+      body.replaceChildren(fragment);
+      const measured = context.packet ? `${context.packet.observations.filter(o => o.state === "ok").length} ${text.measured} / ${context.packet.observations.length} ${text.supplied}` : text.noResults;
+      summary.textContent = `${inventory.protocol} · ${text.shown} ${tasks.length} ${text.of} ${inventory.rows.length} ${text.rows} · ${measured}`;
+      empty.hidden = tasks.length !== 0;
+      wrap.hidden = tasks.length === 0;
+    }
+    search.addEventListener("input", render);
+    language.addEventListener("change", render);
+    clear.addEventListener("click", () => { search.value = ""; language.value = "all"; render(); search.focus(); });
+    render();
+  }
+  async function read(path, expectedSHA) {
+    const response = await fetch(path, {cache:"no-store"});
+    if (!response.ok) throw new Error(`${path}: HTTP ${response.status}`);
+    const bytes = await response.arrayBuffer();
+    const hash = await crypto.subtle.digest("SHA-256", bytes);
+    const sha = [...new Uint8Array(hash)].map(v => v.toString(16).padStart(2, "0")).join("");
+    if (expectedSHA && sha !== expectedSHA) throw new Error(`Pinned bytes changed: ${path}`);
+    return {data:JSON.parse(new TextDecoder().decode(bytes)), sha};
+  }
+  async function start() {
+    const [plan, schema] = await Promise.all([
+      read("benchmarks-plan.json", contract.inventorySHA), read("benchmarks.schema.json", contract.schemaSHA)
+    ]);
+    const context = {inventory:plan.data, packet:null, index:null, error:null, packetSHA:null};
+    try {
+      const feed = await read("benchmarks-feed.json");
+      if (feed.data.results !== null) {
+        if (feed.data.results !== "benchmarks-results.json") throw new Error("Only the local accepted result path is allowed");
+        const results = await read(feed.data.results);
+        context.index = contract.validate(results.data, plan.data, schema.data, contract.revision);
+        context.packet = results.data;
+        context.packetSHA = results.sha;
+      }
+    } catch (error) { context.error = error.message; }
+    document.querySelectorAll(".bench-panel").forEach(section => build(section, context));
+  }
+  start().catch(error => {
+    document.querySelectorAll(".bench-panel").forEach(section => {
+      section.querySelector(".bench-content").replaceChildren(el("p", `${words[section.dataset.locale].loadError} (${error.message})`, "bench-notice"));
+    });
+  });
+})();

benchmarks.schema.json

@@ -0,0 +1,599 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "urn:kolektyw:n05:benchmark-results:1",
+  "type": "object",
+  "properties": {
+    "schema_version": {
+      "const": 1
+    },
+    "protocol_id": {
+      "type": "string",
+      "minLength": 1
+    },
+    "run_id": {
+      "type": "string",
+      "minLength": 1
+    },
+    "models": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "model_id": {
+            "type": "string",
+            "minLength": 1
+          },
+          "repo": {
+            "type": "string",
+            "minLength": 1
+          },
+          "revision": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "weights_sha256": {
+            "anyOf": [
+              {
+                "type": "string",
+                "pattern": "^[0-9a-f]{64}$"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          }
+        },
+        "required": [
+          "model_id",
+          "repo",
+          "revision",
+          "weights_sha256"
+        ],
+        "additionalProperties": false
+      }
+    },
+    "tasks": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "task_id": {
+            "type": "string",
+            "pattern": "^T(0[1-9]|[1-4][0-9]|50)$"
+          },
+          "task": {
+            "type": "string",
+            "minLength": 1
+          },
+          "family": {
+            "type": "string",
+            "minLength": 1
+          },
+          "language": {
+            "enum": [
+              "PL",
+              "EN"
+            ]
+          },
+          "split": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "required": [
+          "task_id",
+          "task",
+          "family",
+          "language",
+          "split"
+        ],
+        "additionalProperties": false
+      }
+    },
+    "observations": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/observation"
+      }
+    },
+    "contrasts": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/contrast"
+      }
+    },
+    "provenance": {
+      "type": "object",
+      "properties": {
+        "inventory_commit": {
+          "type": "string",
+          "minLength": 1
+        },
+        "kind": {
+          "enum": [
+            "measurement",
+            "contract_example"
+          ]
+        }
+      },
+      "required": [
+        "inventory_commit",
+        "kind"
+      ],
+      "additionalProperties": false
+    }
+  },
+  "required": [
+    "schema_version",
+    "protocol_id",
+    "run_id",
+    "models",
+    "tasks",
+    "observations",
+    "contrasts",
+    "provenance"
+  ],
+  "additionalProperties": false,
+  "$defs": {
+    "ci95": {
+      "type": "object",
+      "properties": {
+        "lower": {
+          "type": "number"
+        },
+        "upper": {
+          "type": "number"
+        },
+        "level": {
+          "const": 0.95
+        },
+        "method": {
+          "const": "paired_bootstrap"
+        },
+        "replicates": {
+          "const": 10000
+        },
+        "seed": {
+          "const": 20261028
+        }
+      },
+      "required": [
+        "lower",
+        "upper",
+        "level",
+        "method",
+        "replicates",
+        "seed"
+      ],
+      "additionalProperties": false
+    },
+    "observation": {
+      "type": "object",
+      "properties": {
+        "task_id": {
+          "type": "string",
+          "pattern": "^T(0[1-9]|[1-4][0-9]|50)$"
+        },
+        "model_id": {
+          "type": "string",
+          "minLength": 1
+        },
+        "protocol_id": {
+          "type": "string",
+          "minLength": 1
+        },
+        "metric": {
+          "type": "string",
+          "minLength": 1
+        },
+        "unit": {
+          "enum": [
+            "percent",
+            "score",
+            "byte_ppl"
+          ]
+        },
+        "higher_is_better": {
+          "type": "boolean"
+        },
+        "n_population": {
+          "type": [
+            "integer",
+            "null"
+          ],
+          "minimum": 0
+        },
+        "n_selected": {
+          "type": [
+            "integer",
+            "null"
+          ],
+          "minimum": 0
+        },
+        "n_scored": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "state": {
+          "enum": [
+            "ok",
+            "not_run",
+            "blocked_access",
+            "blocked_runtime",
+            "blocked_security",
+            "blocked_judge",
+            "unsupported",
+            "failed",
+            "skipped"
+          ]
+        },
+        "value": {
+          "type": [
+            "number",
+            "null"
+          ]
+        },
+        "ci95": {
+          "anyOf": [
+            {
+              "type": "object",
+              "properties": {
+                "lower": {
+                  "type": "number"
+                },
+                "upper": {
+                  "type": "number"
+                },
+                "level": {
+                  "const": 0.95
+                },
+                "method": {
+                  "const": "paired_bootstrap"
+                },
+                "replicates": {
+                  "const": 10000
+                },
+                "seed": {
+                  "const": 20261028
+                }
+              },
+              "required": [
+                "lower",
+                "upper",
+                "level",
+                "method",
+                "replicates",
+                "seed"
+              ],
+              "additionalProperties": false
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "source_id_digest": {
+          "anyOf": [
+            {
+              "type": "string",
+              "pattern": "^[0-9a-f]{64}$"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "results_sha256": {
+          "anyOf": [
+            {
+              "type": "string",
+              "pattern": "^[0-9a-f]{64}$"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "runner_sha256": {
+          "anyOf": [
+            {
+              "type": "string",
+              "pattern": "^[0-9a-f]{64}$"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "required": [
+        "task_id",
+        "model_id",
+        "protocol_id",
+        "metric",
+        "unit",
+        "higher_is_better",
+        "n_population",
+        "n_selected",
+        "n_scored",
+        "state",
+        "value",
+        "ci95",
+        "source_id_digest",
+        "results_sha256",
+        "runner_sha256"
+      ],
+      "additionalProperties": false,
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "state": {
+                "const": "ok"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "value": {
+                "type": "number"
+              },
+              "n_scored": {
+                "type": "integer",
+                "minimum": 1
+              },
+              "source_id_digest": {
+                "type": "string",
+                "pattern": "^[0-9a-f]{64}$"
+              },
+              "results_sha256": {
+                "type": "string",
+                "pattern": "^[0-9a-f]{64}$"
+              },
+              "runner_sha256": {
+                "type": "string",
+                "pattern": "^[0-9a-f]{64}$"
+              }
+            }
+          },
+          "else": {
+            "properties": {
+              "value": {
+                "type": "null"
+              },
+              "ci95": {
+                "type": "null"
+              }
+            }
+          }
+        }
+      ]
+    },
+    "contrast": {
+      "type": "object",
+      "properties": {
+        "task_id": {
+          "type": "string",
+          "pattern": "^T(0[1-9]|[1-4][0-9]|50)$"
+        },
+        "model_id": {
+          "type": "string",
+          "minLength": 1
+        },
+        "protocol_id": {
+          "type": "string",
+          "minLength": 1
+        },
+        "model_ref": {
+          "type": "string",
+          "minLength": 1
+        },
+        "delta": {
+          "type": [
+            "number",
+            "null"
+          ]
+        },
+        "ci95": {
+          "anyOf": [
+            {
+              "type": "object",
+              "properties": {
+                "lower": {
+                  "type": "number"
+                },
+                "upper": {
+                  "type": "number"
+                },
+                "level": {
+                  "const": 0.95
+                },
+                "method": {
+                  "const": "paired_bootstrap"
+                },
+                "replicates": {
+                  "const": 10000
+                },
+                "seed": {
+                  "const": 20261028
+                }
+              },
+              "required": [
+                "lower",
+                "upper",
+                "level",
+                "method",
+                "replicates",
+                "seed"
+              ],
+              "additionalProperties": false
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "p_raw": {
+          "type": [
+            "number",
+            "null"
+          ],
+          "minimum": 0,
+          "maximum": 1
+        },
+        "p_holm": {
+          "type": [
+            "number",
+            "null"
+          ],
+          "minimum": 0,
+          "maximum": 1
+        },
+        "family_size": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "verdict": {
+          "enum": [
+            "withheld",
+            "better",
+            "worse",
+            "inconclusive"
+          ]
+        },
+        "review": {
+          "type": "object",
+          "properties": {
+            "status": {
+              "enum": [
+                "pending",
+                "accepted",
+                "rejected"
+              ]
+            },
+            "actor": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "artifact_sha256": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "pattern": "^[0-9a-f]{64}$"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            }
+          },
+          "required": [
+            "status",
+            "actor",
+            "artifact_sha256"
+          ],
+          "additionalProperties": false,
+          "allOf": [
+            {
+              "if": {
+                "properties": {
+                  "status": {
+                    "const": "accepted"
+                  }
+                }
+              },
+              "then": {
+                "properties": {
+                  "actor": {
+                    "type": "string",
+                    "minLength": 1
+                  },
+                  "artifact_sha256": {
+                    "type": "string",
+                    "pattern": "^[0-9a-f]{64}$"
+                  }
+                }
+              }
+            }
+          ]
+        }
+      },
+      "required": [
+        "task_id",
+        "model_id",
+        "protocol_id",
+        "model_ref",
+        "delta",
+        "ci95",
+        "p_raw",
+        "p_holm",
+        "family_size",
+        "verdict",
+        "review"
+      ],
+      "additionalProperties": false,
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "verdict": {
+                "enum": [
+                  "better",
+                  "worse",
+                  "inconclusive"
+                ]
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "review": {
+                "properties": {
+                  "status": {
+                    "const": "accepted"
+                  }
+                }
+              },
+              "delta": {
+                "type": "number"
+              },
+              "p_raw": {
+                "type": "number"
+              },
+              "p_holm": {
+                "type": "number"
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "review": {
+                "properties": {
+                  "status": {
+                    "enum": [
+                      "pending",
+                      "rejected"
+                    ]
+                  }
+                }
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "verdict": {
+                "const": "withheld"
+              }
+            }
+          }
+        }
+      ]
+    }
+  }
+}

import-benchmarks.cjs

@@ -0,0 +1,32 @@
+"use strict";
+// Offline adapter, not a scorer or publisher. Validates N05's pinned wire
+// contract and cross-field invariants before replacing the local result feed.
+// Usage: node import-benchmarks.cjs PATH_TO_MEASUREMENT_PACKET.json
+const fs = require("node:fs");
+const path = require("node:path");
+const crypto = require("node:crypto");
+const contract = require("./benchmarks-contract.js");
+function pinned(name, expected) {
+  const raw = fs.readFileSync(path.join(__dirname, name));
+  if (crypto.createHash("sha256").update(raw).digest("hex") !== expected) throw new Error(`Pinned input changed: ${name}`);
+  return JSON.parse(raw.toString("utf8"));
+}
+function main() {
+  if (process.argv.length !== 3) throw new Error("Usage: node import-benchmarks.cjs PACKET.json");
+  const inventory = pinned("benchmarks-plan.json", contract.inventorySHA);
+  const schema = pinned("benchmarks.schema.json", contract.schemaSHA);
+  const raw = fs.readFileSync(process.argv[2]);
+  const packet = JSON.parse(raw.toString("utf8"));
+  contract.validate(packet, inventory, schema, contract.revision);
+  // Validation happens before any write. Feed configuration is written last.
+  const output = path.join(__dirname, "benchmarks-results.json");
+  const staging = output + ".new";
+  fs.writeFileSync(staging, raw);
+  fs.renameSync(staging, output);
+  const feed = path.join(__dirname, "benchmarks-feed.json");
+  fs.writeFileSync(feed + ".new", '{\n  "results": "benchmarks-results.json"\n}\n');
+  fs.renameSync(feed + ".new", feed);
+  console.log(JSON.stringify({run_id:packet.run_id,protocol_id:packet.protocol_id,kind:packet.provenance.kind,
+    observations:packet.observations.length,results_sha256:crypto.createHash("sha256").update(raw).digest("hex")}));
+}
+try { main(); } catch (error) { console.error(`STOP: ${error.message}`); process.exitCode = 1; }

index.html

@@ -95,6 +95,9 @@
     figure:has(> img) img { width:760px; max-width:none; }
   }
 </style>
+<link rel="stylesheet" href="benchmarks.css">
+<script src="benchmarks-contract.js" defer></script>
+<script src="benchmarks.js" defer></script>
 </head>
 <body data-lang="en">
 <nav class="lang" aria-label="Language"><button type="button" data-set="en" aria-pressed="true">EN</button><button type="button" data-set="pl" aria-pressed="false">PL</button></nav>
@@ -242,6 +245,13 @@
   used a constant learning rate; a final decay has not been applied, so these are not end-of-training numbers for the model line.</p>
 </section>
 
+<section class="bench-panel" data-locale="en" aria-labelledby="bench-title-en">
+  <h2 id="bench-title-en">Benchmark campaign · N05-50</h2>
+  <p class="note">Protocol inventory, not fifty completed measurements. Related variants are not independent datasets. Panel-200 and full Open PL replication must remain separate.</p>
+  <div class="bench-content" role="status">Loading protocol inventory…</div>
+  <noscript><p>JavaScript is required for filtering. <a href="benchmarks-plan.json">Download the pinned task inventory</a>.</p></noscript>
+</section>
+
 <section>
   <h2>How we do it</h2>
   <ol class="steps">
@@ -421,6 +431,13 @@
   szła przy stałym tempie uczenia; końcowego wygaszania nie zastosowano, więc to nie są końcowe liczby tej linii modelu.</p>
 </section>
 
+<section class="bench-panel" data-locale="pl" aria-labelledby="bench-title-pl">
+  <h2 id="bench-title-pl">Kampania benchmarków · N05-50</h2>
+  <p class="note">Inwentarz protokołu, nie pięćdziesiąt wykonanych pomiarów. Powiązane warianty nie są niezależnymi zbiorami. Panel-200 i pełna replika Open PL pozostają osobnymi skalami.</p>
+  <div class="bench-content" role="status">Wczytuję inwentarz protokołu…</div>
+  <noscript><p>Filtrowanie wymaga JavaScript. <a href="benchmarks-plan.json">Pobierz przypięty inwentarz zadań</a>.</p></noscript>
+</section>
+
 <section>
   <h2>Jak to robimy</h2>
   <ol class="steps">