Publish v0.3.0 reproducibility scripts

Build, validation, audit, Parquet and workbook generation scripts for the v0.3.0 release.

scripts/audit-v03.mjs

@@ -0,0 +1,1018 @@
+#!/usr/bin/env node
+
+/**
+ * Deterministic, read-only acceptance audit for the v0.3 CSV release.
+ *
+ * Usage:
+ *   node scripts/audit-v03.mjs [data-directory]
+ *
+ * The script writes nothing. It prints one stable JSON report and exits 1 only
+ * when blocking errors exist. Warnings never change the exit status.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(here, "..");
+const dataDir = path.resolve(process.argv[2] || path.join(packageRoot, "data"));
+
+const blocking = [];
+const advisory = [];
+const loaded = new Map();
+
+function issue(severity, test, code, table, rowId, message) {
+  const item = {
+    test,
+    code,
+    table: table || null,
+    row_id: rowId || null,
+    message
+  };
+  (severity === "error" ? blocking : advisory).push(item);
+}
+
+const error = (...args) => issue("error", ...args);
+const warn = (...args) => issue("warning", ...args);
+
+function parseCsv(text, filename) {
+  const input = text.replace(/^\uFEFF/, "");
+  const records = [];
+  let record = [];
+  let field = "";
+  let quoted = false;
+
+  for (let i = 0; i < input.length; i += 1) {
+    const char = input[i];
+    if (quoted) {
+      if (char === '"') {
+        if (input[i + 1] === '"') {
+          field += '"';
+          i += 1;
+        } else {
+          quoted = false;
+        }
+      } else {
+        field += char;
+      }
+      continue;
+    }
+    if (char === '"' && field === "") {
+      quoted = true;
+    } else if (char === ",") {
+      record.push(field);
+      field = "";
+    } else if (char === "\n") {
+      record.push(field);
+      records.push(record);
+      record = [];
+      field = "";
+    } else if (char !== "\r") {
+      field += char;
+    }
+  }
+
+  if (quoted) {
+    error("T00_SCHEMA", "CSV_UNCLOSED_QUOTE", filename, null, "CSV ends inside a quoted field");
+  }
+  if (field !== "" || record.length > 0) {
+    record.push(field);
+    records.push(record);
+  }
+  while (records.length && records.at(-1).every((value) => value === "")) records.pop();
+  if (!records.length) {
+    error("T00_SCHEMA", "CSV_EMPTY", filename, null, "CSV has no header row");
+    return { headers: [], rows: [] };
+  }
+
+  const headers = records[0].map((value) => value.trim());
+  const duplicateHeaders = headers.filter((value, index) => headers.indexOf(value) !== index);
+  for (const header of [...new Set(duplicateHeaders)].sort()) {
+    error("T00_SCHEMA", "DUPLICATE_HEADER", filename, null, `Duplicate header: ${header}`);
+  }
+
+  const rows = [];
+  for (let i = 1; i < records.length; i += 1) {
+    const values = records[i];
+    if (values.every((value) => value === "")) continue;
+    if (values.length !== headers.length) {
+      error(
+        "T00_SCHEMA",
+        "CSV_WIDTH",
+        filename,
+        `line:${i + 1}`,
+        `Expected ${headers.length} cells; found ${values.length}`
+      );
+    }
+    const row = { __line: i + 1 };
+    headers.forEach((header, index) => {
+      row[header] = values[index] ?? "";
+    });
+    rows.push(row);
+  }
+  return { headers, rows };
+}
+
+function loadTable(name, requiredHeaders, required = true) {
+  const filename = `${name}.csv`;
+  const filepath = path.join(dataDir, filename);
+  if (!fs.existsSync(filepath)) {
+    (required ? error : warn)(
+      "T00_SCHEMA",
+      required ? "REQUIRED_TABLE_MISSING" : "OPTIONAL_TABLE_MISSING",
+      name,
+      null,
+      `${filename} is missing`
+    );
+    const empty = { headers: [], rows: [], exists: false };
+    loaded.set(name, empty);
+    return empty;
+  }
+  const parsed = parseCsv(fs.readFileSync(filepath, "utf8"), name);
+  const headerSet = new Set(parsed.headers);
+  for (const header of requiredHeaders) {
+    if (!headerSet.has(header)) {
+      error("T00_SCHEMA", "REQUIRED_COLUMN_MISSING", name, null, `Required column is missing: ${header}`);
+    }
+  }
+  const table = { ...parsed, exists: true };
+  loaded.set(name, table);
+  return table;
+}
+
+const requiredColumns = {
+  cases: [
+    "case_id", "case_family_id", "title", "country", "region", "election_date_start",
+    "case_status", "as_of_date", "record_type", "manipulation_assessment", "last_verified"
+  ],
+  claims: ["claim_id", "case_id", "claim_type", "evidence_label", "source_ids"],
+  sources: ["source_id", "source_type", "publication_date", "retrieved_at"],
+  candidates: ["candidate_id", "region", "research_status"],
+  case_catalog: [
+    "catalog_id", "record_layer", "record_type", "manipulation_assessment",
+    "incident_count_eligible", "research_status"
+  ],
+  case_actors: [
+    "case_actor_id", "case_id", "actor_name", "actor_role", "actor_type",
+    "attribution_status", "control_dimension", "source_claim_ids"
+  ],
+  technology_uses: [
+    "tech_use_id", "case_id", "provider", "product_or_model", "version", "access_type",
+    "technology_role", "use_status", "provenance_status", "evidence_label", "source_claim_ids", "notes"
+  ],
+  content_items: ["content_item_id", "case_id", "source_claim_ids"],
+  pathways: [
+    "pathway_id", "case_id", "affected_agency", "control_shift_from", "control_shift_to",
+    "mechanism", "power_recipient", "harm_pathway", "agency_transfer_status",
+    "assessment_label", "source_claim_ids"
+  ],
+  observations: [
+    "observation_id", "case_id", "pathway_id", "claim_id", "metric_family", "metric_name",
+    "value_low", "value_best", "value_high", "unit", "denominator", "unique_entity_status",
+    "platform", "geographic_scope", "measurement_window", "measurement_method", "causal_status",
+    "source_id", "as_of_date", "limitations"
+  ],
+  model_evaluations: [
+    "evaluation_id", "title", "country", "evaluation_window", "election_or_context",
+    "systems_tested", "versions_known", "interface", "languages", "sample_unit", "sample_size",
+    "design", "primary_metrics", "headline_results", "causal_scope", "source_id",
+    "data_availability", "notes"
+  ],
+  claim_evidence: ["claim_evidence_id", "claim_id", "source_id", "relation", "evidence_scope", "directness"],
+  case_elections: ["case_election_id", "case_id", "election_id", "relation"],
+  sampling_frame: [
+    "frame_id", "region", "selection_basis", "search_status", "search_languages", "source_channels",
+    "included_case_count", "candidate_count", "negative_search_recorded", "known_gap", "last_searched"
+  ],
+  coverage_summary: ["region", "included_case_count", "candidate_count", "model_evaluation_count", "coverage_note"],
+  research_view: [
+    "pathway_id", "case_id", "record_type", "manipulation_assessment", "system_or_model",
+    "controller", "influence_vector", "target", "affected_agency", "agency_transfer_status",
+    "power_recipient", "reach_summary", "behavioural_effect", "electoral_effect", "evidence_strength"
+  ],
+  official_data_sources: ["official_source_id", "case_family_id", "data_status", "retrieved_at"],
+  official_elections: [
+    "election_id", "case_family_id", "linked_case_ids", "election_date", "election_status",
+    "legal_result_status", "official_source_ids", "as_of_date"
+  ],
+  official_turnout: [
+    "turnout_id", "election_id", "geographic_unit_type", "geographic_unit_code", "data_status",
+    "electorate_measure", "participation_measure", "registered_voters", "ballots_cast", "valid_votes",
+    "invalid_votes", "turnout_rate", "reporting_units_total", "reporting_units_counted",
+    "official_source_id", "as_of_date", "notes"
+  ],
+  official_results: [
+    "result_id", "election_id", "geographic_unit_type", "geographic_unit_code", "contest_name",
+    "candidate_or_option", "votes", "valid_vote_share", "rank", "result_status", "coverage_status",
+    "official_source_id", "as_of_date", "notes"
+  ]
+};
+
+for (const [name, headers] of Object.entries(requiredColumns)) loadTable(name, headers);
+
+const rows = (name) => loaded.get(name)?.rows || [];
+const ids = (value) => String(value || "").split("|").map((part) => part.trim()).filter(Boolean);
+const clean = (value) => String(value ?? "").trim();
+const lower = (value) => clean(value).toLowerCase();
+const isBlank = (value) => clean(value) === "";
+const isIsoDate = (value) => /^\d{4}-\d{2}-\d{2}$/.test(clean(value));
+
+function rowId(row, table) {
+  const likely = [
+    `${table.replace(/s$/, "")}_id`, "case_actor_id", "tech_use_id", "content_item_id",
+    "claim_evidence_id", "case_election_id", "case_id", "pathway_id", "observation_id", "evaluation_id",
+    "frame_id", "catalog_id", "result_id", "turnout_id", "election_id", "source_id", "claim_id"
+  ];
+  for (const field of likely) if (!isBlank(row[field])) return clean(row[field]);
+  return `line:${row.__line}`;
+}
+
+function requireNonBlank(row, fields, test, table, id) {
+  for (const field of fields) {
+    if (isBlank(row[field])) error(test, "REQUIRED_VALUE_MISSING", table, id, `Required value is blank: ${field}`);
+  }
+}
+
+function uniqueIndex(table, field) {
+  const index = new Map();
+  for (const row of rows(table)) {
+    const id = clean(row[field]);
+    const ref = rowId(row, table);
+    if (!id) {
+      error("T03_FOREIGN_KEYS", "PRIMARY_KEY_MISSING", table, ref, `Primary key is blank: ${field}`);
+    } else if (index.has(id)) {
+      error("T03_FOREIGN_KEYS", "PRIMARY_KEY_DUPLICATE", table, id, `Duplicate ${field}: ${id}`);
+    } else {
+      index.set(id, row);
+    }
+  }
+  return index;
+}
+
+const primaryKeys = {
+  cases: "case_id", claims: "claim_id", sources: "source_id", candidates: "candidate_id",
+  case_catalog: "catalog_id", case_actors: "case_actor_id", technology_uses: "tech_use_id",
+  content_items: "content_item_id", pathways: "pathway_id", observations: "observation_id",
+  model_evaluations: "evaluation_id", claim_evidence: "claim_evidence_id",
+  case_elections: "case_election_id", sampling_frame: "frame_id",
+  official_data_sources: "official_source_id", official_elections: "election_id",
+  official_turnout: "turnout_id", official_results: "result_id"
+};
+const index = Object.fromEntries(Object.entries(primaryKeys).map(([table, field]) => [table, uniqueIndex(table, field)]));
+
+function requireFk(test, table, row, field, targetTable, targetIndex = index[targetTable], allowBlank = false) {
+  const values = ids(row[field]);
+  const id = rowId(row, table);
+  if (!values.length && !allowBlank) {
+    error(test, "FOREIGN_KEY_MISSING", table, id, `${field} is blank; expected ${targetTable}`);
+    return;
+  }
+  for (const value of values) {
+    if (!targetIndex?.has(value)) {
+      error(test, "FOREIGN_KEY_UNKNOWN", table, id, `${field} references unknown ${targetTable}: ${value}`);
+    }
+  }
+}
+
+const caseFamilyIds = new Set(rows("cases").map((row) => clean(row.case_family_id)).filter(Boolean));
+const cutoffCandidates = rows("cases").map((row) => clean(row.as_of_date)).filter(isIsoDate).sort();
+const cutoff = cutoffCandidates.at(-1) || null;
+
+// T01 — every included case has an explicit, controlled record classification.
+const validRecordTypes = new Set([
+  "observed_incident", "observed_network", "observed_campaign_set", "election_wide_case",
+  "preparedness_file", "observational_null_case", "negative_case"
+]);
+const validManipulationAssessments = new Set([
+  "manipulation_confirmed", "manipulation_probable", "mixed_documented_manipulation",
+  "transparent_contested_use", "manipulation_not_established", "no_manipulation_observed",
+  "preparedness_not_incident", "not_applicable"
+]);
+for (const row of rows("cases")) {
+  const id = rowId(row, "cases");
+  requireNonBlank(row, ["record_type", "manipulation_assessment"], "T01_RECORD_CLASSIFICATION", "cases", id);
+  if (!validRecordTypes.has(clean(row.record_type))) {
+    error("T01_RECORD_CLASSIFICATION", "RECORD_TYPE_INVALID", "cases", id, `Unknown record_type: ${clean(row.record_type)}`);
+  }
+  if (!validManipulationAssessments.has(clean(row.manipulation_assessment))) {
+    error(
+      "T01_RECORD_CLASSIFICATION", "MANIPULATION_ASSESSMENT_INVALID", "cases", id,
+      `Unknown manipulation_assessment: ${clean(row.manipulation_assessment)}`
+    );
+  }
+  if (!isIsoDate(row.as_of_date) || !isIsoDate(row.last_verified)) {
+    error("T01_RECORD_CLASSIFICATION", "CASE_DATE_INVALID", "cases", id, "as_of_date and last_verified must be ISO dates");
+  } else if (clean(row.last_verified) > clean(row.as_of_date)) {
+    error("T01_RECORD_CLASSIFICATION", "VERIFIED_AFTER_AS_OF", "cases", id, "last_verified is after as_of_date");
+  }
+  if (/^(manipulation_confirmed|manipulation_probable|mixed_documented_manipulation)$/.test(clean(row.manipulation_assessment))) {
+    const processClaims = rows("claims").filter(
+      (claim) => clean(claim.case_id) === clean(row.case_id) &&
+        ["occurrence", "mechanism", "attribution", "intent"].includes(clean(claim.claim_type)) &&
+        ["established_evidence", "strong_inference"].includes(clean(claim.evidence_label)) &&
+        ids(claim.source_ids).length > 0
+    );
+    if (!processClaims.length) {
+      error(
+        "T01_RECORD_CLASSIFICATION", "MANIPULATION_WITHOUT_PROCESS_EVIDENCE", "cases", id,
+        "Confirmed/probable/mixed manipulation requires an evidence-backed process claim"
+      );
+    }
+  }
+}
+
+// T02 — preparedness and model-evaluation records can never inflate incident counts.
+const trueValues = new Set(["true"]);
+const falseValues = new Set(["false"]);
+for (const row of rows("cases")) {
+  const id = rowId(row, "cases");
+  const isPreparedness = clean(row.record_type) === "preparedness_file";
+  if (isPreparedness && clean(row.manipulation_assessment) !== "preparedness_not_incident") {
+    error(
+      "T02_INCIDENT_DENOMINATOR", "PREPAREDNESS_ASSESSMENT", "cases", id,
+      "preparedness_file must use manipulation_assessment=preparedness_not_incident"
+    );
+  }
+  if (!isPreparedness && clean(row.manipulation_assessment) === "preparedness_not_incident") {
+    error(
+      "T02_INCIDENT_DENOMINATOR", "PREPAREDNESS_TYPE_MISMATCH", "cases", id,
+      "preparedness_not_incident is only valid for record_type=preparedness_file"
+    );
+  }
+}
+for (const row of rows("case_catalog")) {
+  const id = rowId(row, "case_catalog");
+  const eligibility = lower(row.incident_count_eligible);
+  if (!trueValues.has(eligibility) && !falseValues.has(eligibility)) {
+    error(
+      "T02_INCIDENT_DENOMINATOR", "INCIDENT_ELIGIBILITY_INVALID", "case_catalog", id,
+      "incident_count_eligible must be an explicit boolean"
+    );
+  }
+  if (
+    clean(row.record_type) === "preparedness_file" ||
+    /model.?evaluation/i.test(clean(row.record_layer)) ||
+    /model.?evaluation/i.test(clean(row.research_status))
+  ) {
+    if (!falseValues.has(eligibility)) {
+      error(
+        "T02_INCIDENT_DENOMINATOR", "NON_INCIDENT_COUNTED", "case_catalog", id,
+        "Preparedness and model-evaluation records must have incident_count_eligible=false"
+      );
+    }
+  }
+}
+const preparednessCatalogCount = rows("case_catalog").filter((row) => clean(row.record_type) === "preparedness_file").length;
+const preparednessCaseCount = rows("cases").filter((row) => clean(row.record_type) === "preparedness_file").length;
+if (rows("case_catalog").length && preparednessCatalogCount !== preparednessCaseCount) {
+  error(
+    "T02_INCIDENT_DENOMINATOR", "PREPAREDNESS_CATALOG_COUNT_MISMATCH", "case_catalog", null,
+    `case_catalog has ${preparednessCatalogCount} preparedness rows; cases.csv has ${preparednessCaseCount}`
+  );
+}
+const modelCatalogCount = rows("case_catalog").filter((row) => clean(row.record_layer) === "empirical_model_study").length;
+if (rows("case_catalog").length && modelCatalogCount !== rows("model_evaluations").length) {
+  error(
+    "T02_INCIDENT_DENOMINATOR", "MODEL_EVALUATION_CATALOG_COUNT_MISMATCH", "case_catalog", null,
+    `case_catalog has ${modelCatalogCount} model-evaluation rows; model_evaluations.csv has ${rows("model_evaluations").length}`
+  );
+}
+for (const row of rows("pathways")) {
+  const parent = index.cases.get(clean(row.case_id));
+  if (parent?.record_type === "preparedness_file" && clean(row.agency_transfer_status) !== "not_an_incident") {
+    error(
+      "T02_INCIDENT_DENOMINATOR", "PREPAREDNESS_PATHWAY_STATUS", "pathways", rowId(row, "pathways"),
+      "A preparedness pathway must use agency_transfer_status=not_an_incident"
+    );
+  }
+}
+
+// T03 — relational integrity across the research and official-election layers.
+for (const row of rows("claims")) requireFk("T03_FOREIGN_KEYS", "claims", row, "case_id", "cases");
+for (const table of ["case_actors", "technology_uses", "content_items", "pathways", "observations", "case_elections"]) {
+  for (const row of rows(table)) requireFk("T03_FOREIGN_KEYS", table, row, "case_id", "cases");
+}
+for (const table of ["case_actors", "technology_uses", "content_items", "pathways"]) {
+  for (const row of rows(table)) {
+    requireFk("T03_FOREIGN_KEYS", table, row, "source_claim_ids", "claims");
+    for (const claimId of ids(row.source_claim_ids)) {
+      const claim = index.claims.get(claimId);
+      if (claim && clean(claim.case_id) !== clean(row.case_id)) {
+        error(
+          "T03_FOREIGN_KEYS", "CROSS_CASE_SOURCE_CLAIM", table, rowId(row, table),
+          `source_claim_ids references a claim from another case: ${claimId}`
+        );
+      }
+    }
+  }
+}
+for (const row of rows("observations")) {
+  requireFk("T03_FOREIGN_KEYS", "observations", row, "pathway_id", "pathways");
+  requireFk("T03_FOREIGN_KEYS", "observations", row, "claim_id", "claims");
+  requireFk("T03_FOREIGN_KEYS", "observations", row, "source_id", "sources");
+  const caseId = clean(row.case_id);
+  const pathway = index.pathways.get(clean(row.pathway_id));
+  const claim = index.claims.get(clean(row.claim_id));
+  if (pathway && clean(pathway.case_id) !== caseId) {
+    error("T03_FOREIGN_KEYS", "CROSS_CASE_PATHWAY", "observations", rowId(row, "observations"), "pathway_id belongs to another case");
+  }
+  if (claim && clean(claim.case_id) !== caseId) {
+    error("T03_FOREIGN_KEYS", "CROSS_CASE_CLAIM", "observations", rowId(row, "observations"), "claim_id belongs to another case");
+  }
+}
+for (const row of rows("model_evaluations")) requireFk("T03_FOREIGN_KEYS", "model_evaluations", row, "source_id", "sources");
+for (const row of rows("claim_evidence")) {
+  requireFk("T03_FOREIGN_KEYS", "claim_evidence", row, "claim_id", "claims");
+  requireFk("T03_FOREIGN_KEYS", "claim_evidence", row, "source_id", "sources");
+}
+for (const row of rows("case_elections")) requireFk("T03_FOREIGN_KEYS", "case_elections", row, "election_id", "official_elections");
+for (const row of rows("official_elections")) {
+  requireFk("T03_FOREIGN_KEYS", "official_elections", row, "linked_case_ids", "cases");
+  requireFk("T03_FOREIGN_KEYS", "official_elections", row, "official_source_ids", "official_data_sources");
+  if (!caseFamilyIds.has(clean(row.case_family_id))) {
+    error("T03_FOREIGN_KEYS", "CASE_FAMILY_UNKNOWN", "official_elections", rowId(row, "official_elections"), `Unknown case_family_id: ${clean(row.case_family_id)}`);
+  }
+}
+for (const table of ["official_turnout", "official_results"]) {
+  for (const row of rows(table)) {
+    requireFk("T03_FOREIGN_KEYS", table, row, "election_id", "official_elections");
+    requireFk("T03_FOREIGN_KEYS", table, row, "official_source_id", "official_data_sources");
+    const election = index.official_elections.get(clean(row.election_id));
+    const source = index.official_data_sources.get(clean(row.official_source_id));
+    if (election && source && clean(election.case_family_id) !== clean(source.case_family_id)) {
+      error("T03_FOREIGN_KEYS", "OFFICIAL_SOURCE_FAMILY_MISMATCH", table, rowId(row, table), "Official source and election belong to different case families");
+    }
+  }
+}
+for (const row of rows("official_data_sources")) {
+  if (!caseFamilyIds.has(clean(row.case_family_id))) {
+    error("T03_FOREIGN_KEYS", "CASE_FAMILY_UNKNOWN", "official_data_sources", rowId(row, "official_data_sources"), `Unknown case_family_id: ${clean(row.case_family_id)}`);
+  }
+}
+for (const row of rows("research_view")) {
+  requireFk("T03_FOREIGN_KEYS", "research_view", row, "case_id", "cases");
+  requireFk("T03_FOREIGN_KEYS", "research_view", row, "pathway_id", "pathways");
+  const pathway = index.pathways.get(clean(row.pathway_id));
+  if (pathway && clean(pathway.case_id) !== clean(row.case_id)) {
+    error("T03_FOREIGN_KEYS", "RESEARCH_VIEW_PATHWAY_CASE_MISMATCH", "research_view", rowId(row, "research_view"), "Research-view pathway belongs to another case");
+  }
+}
+
+// T04 — a pathway is an auditable control-transfer proposition, not a narrative blob.
+const validAgencyStatuses = new Set([
+  "full_chain_observed", "partial_chain_observed", "mechanism_observed_effect_unknown",
+  "mechanism_inferred", "plausible_hypothesis", "no_transfer_observed", "insufficient_evidence",
+  "not_an_incident"
+]);
+const validAssessmentLabels = new Set([
+  "established_evidence", "strong_inference", "plausible_hypothesis", "speculative_scenario",
+  "open_question", "not_applicable"
+]);
+const pathwaysByCase = new Map();
+for (const row of rows("pathways")) {
+  const id = rowId(row, "pathways");
+  requireNonBlank(
+    row,
+    [
+      "case_id", "affected_agency", "control_shift_from", "control_shift_to", "mechanism",
+      "power_recipient", "harm_pathway", "agency_transfer_status", "assessment_label", "source_claim_ids"
+    ],
+    "T04_PATHWAY", "pathways", id
+  );
+  if (!validAgencyStatuses.has(clean(row.agency_transfer_status))) {
+    error("T04_PATHWAY", "AGENCY_STATUS_INVALID", "pathways", id, `Unknown agency_transfer_status: ${clean(row.agency_transfer_status)}`);
+  }
+  if (!validAssessmentLabels.has(clean(row.assessment_label))) {
+    error("T04_PATHWAY", "ASSESSMENT_LABEL_INVALID", "pathways", id, `Unknown assessment_label: ${clean(row.assessment_label)}`);
+  }
+  if (clean(row.agency_transfer_status) === "not_an_incident" && index.cases.get(clean(row.case_id))?.record_type !== "preparedness_file") {
+    warn("T04_PATHWAY", "NON_PREPAREDNESS_NOT_INCIDENT", "pathways", id, "not_an_incident is attached to a non-preparedness case; verify deliberate negative-case coding");
+  }
+  const text = [row.mechanism, row.harm_pathway, row.observed_outcome].join(" ").toLowerCase();
+  if (/(defen[cs]e|mitigat|monitoring|safeguard|enforcement)/.test(text) && /(manipulat|impersonat|decept|amplif|influence)/.test(text)) {
+    warn("T04_PATHWAY", "OFFENSE_DEFENSE_CONFLATED", "pathways", id, "Pathway text appears to combine offensive influence and defensive response; split if they are distinct mechanisms");
+  }
+  const caseId = clean(row.case_id);
+  if (!pathwaysByCase.has(caseId)) pathwaysByCase.set(caseId, []);
+  pathwaysByCase.get(caseId).push(row);
+}
+for (const row of rows("cases")) {
+  if (!pathwaysByCase.has(clean(row.case_id))) {
+    error("T04_PATHWAY", "CASE_WITHOUT_PATHWAY", "cases", rowId(row, "cases"), "Every case must have at least one pathway assessment");
+  }
+}
+for (const row of rows("case_actors")) {
+  requireNonBlank(row, ["actor_name", "actor_role", "actor_type", "attribution_status", "control_dimension"], "T04_PATHWAY", "case_actors", rowId(row, "case_actors"));
+}
+for (const row of rows("technology_uses")) {
+  const id = rowId(row, "technology_uses");
+  requireNonBlank(row, ["provider", "product_or_model", "technology_role", "use_status", "provenance_status", "evidence_label"], "T04_PATHWAY", "technology_uses", id);
+  if (isBlank(row.version) && !/(not established|not identified|unknown|not disclosed|unavailable)/i.test(clean(row.notes))) {
+    error("T04_PATHWAY", "MODEL_VERSION_BLANK_UNEXPLAINED", "technology_uses", id, "A blank version requires an explicit limitation in notes");
+  }
+  if (
+    lower(row.version) === "unknown" &&
+    !/(unknown|not disclosed|not identified|unavailable|does not identify|does not establish which service|not product-level|exact model|exact producer|exact models|provider identification|public record|predominantly non-ai|do not infer|exact model, api)/i.test(clean(row.notes))
+  ) {
+    error("T04_PATHWAY", "UNKNOWN_MODEL_VERSION_UNEXPLAINED", "technology_uses", id, "version=unknown requires an explicit limitation in notes");
+  }
+}
+const actorCaseIds = new Set(rows("case_actors").map((row) => clean(row.case_id)));
+const technologyCaseIds = new Set(rows("technology_uses").map((row) => clean(row.case_id)));
+for (const row of rows("cases")) {
+  const id = rowId(row, "cases");
+  if (clean(row.record_type) !== "preparedness_file" && !actorCaseIds.has(clean(row.case_id))) {
+    error("T04_PATHWAY", "CASE_WITHOUT_ACTOR", "case_actors", id, "Every case must identify at least one actor or explicitly coded unknown actor");
+  }
+  if (
+    clean(row.record_type) !== "preparedness_file" &&
+    /^(confirmed|probable|mixed)$/.test(clean(row.generative_ai_status)) &&
+    !technologyCaseIds.has(clean(row.case_id))
+  ) {
+    error("T04_PATHWAY", "AI_CASE_WITHOUT_TECHNOLOGY", "technology_uses", id, "A case with material generative AI must have at least one technology-use row");
+  }
+}
+
+// T05 — all quantitative observations retain numeric values, denominators and causal status.
+function parseNumber(value) {
+  if (isBlank(value)) return null;
+  const number = Number(value);
+  return Number.isFinite(number) ? number : Number.NaN;
+}
+function isCountMetric(row) {
+  return /(count|reach|engagement|volume|audience|network|views?|impressions?|accounts?|followers?|posts?|likes?|shares?|comments?|calls?|questions?|votes?|ballots?)/i.test(
+    [row.metric_family, row.metric_name, row.unit].join(" ")
+  );
+}
+const causalValues = new Set([
+  "descriptive_only", "descriptive_non_causal", "non_causal", "no", "unknown", "not_applicable", "association_only",
+  "experimental_causal_estimate", "quasi_experimental_causal_estimate", "causal_estimate", "causal_estimate_limited"
+]);
+for (const row of rows("observations")) {
+  const id = rowId(row, "observations");
+  requireNonBlank(
+    row,
+    [
+      "case_id", "pathway_id", "claim_id", "metric_family", "metric_name", "unit", "denominator",
+      "unique_entity_status", "platform", "geographic_scope", "measurement_window", "measurement_method",
+      "causal_status", "source_id", "as_of_date", "limitations"
+    ],
+    "T05_OBSERVATIONS", "observations", id
+  );
+  const values = ["value_low", "value_best", "value_high"].map((field) => [field, parseNumber(row[field])]);
+  if (values.every(([, value]) => value === null)) {
+    error("T05_OBSERVATIONS", "NUMERIC_VALUE_MISSING", "observations", id, "At least one of value_low, value_best or value_high is required");
+  }
+  for (const [field, value] of values) {
+    if (Number.isNaN(value)) error("T05_OBSERVATIONS", "NUMERIC_VALUE_INVALID", "observations", id, `${field} is not a finite number`);
+    if (value !== null && isCountMetric(row) && value < 0) error("T05_OBSERVATIONS", "COUNT_NEGATIVE", "observations", id, `${field} is negative for a count/reach metric`);
+  }
+  const lowValue = parseNumber(row.value_low);
+  const bestValue = parseNumber(row.value_best);
+  const highValue = parseNumber(row.value_high);
+  if (lowValue !== null && bestValue !== null && lowValue > bestValue) {
+    error("T05_OBSERVATIONS", "INTERVAL_ORDER", "observations", id, "value_low exceeds value_best");
+  }
+  if (bestValue !== null && highValue !== null && bestValue > highValue) {
+    error("T05_OBSERVATIONS", "INTERVAL_ORDER", "observations", id, "value_best exceeds value_high");
+  }
+  if (lowValue !== null && highValue !== null && lowValue > highValue) {
+    error("T05_OBSERVATIONS", "INTERVAL_ORDER", "observations", id, "value_low exceeds value_high");
+  }
+  const causalStatus = clean(row.causal_status);
+  if (!causalValues.has(causalStatus)) {
+    error("T05_OBSERVATIONS", "CAUSAL_STATUS_INVALID", "observations", id, `Unknown causal_status: ${causalStatus}`);
+  }
+  if (/causal_estimate/.test(causalStatus)) {
+    const claim = index.claims.get(clean(row.claim_id));
+    if (!claim || !["behavioural_effect", "electoral_effect"].includes(clean(claim.claim_type))) {
+      error("T05_OBSERVATIONS", "CAUSAL_CLAIM_TYPE", "observations", id, "A causal estimate must link to a behavioural_effect or electoral_effect claim");
+    }
+    if (lowValue === null || bestValue === null || highValue === null) {
+      error("T05_OBSERVATIONS", "CAUSAL_UNCERTAINTY_MISSING", "observations", id, "A causal estimate requires low, best and high values");
+    }
+    if (/(official.?result|turnout|administrative total)/i.test(clean(row.measurement_method))) {
+      error("T05_OBSERVATIONS", "OFFICIAL_OUTCOME_AS_CAUSAL_DESIGN", "observations", id, "Official results or turnout alone cannot identify a causal effect");
+    }
+  }
+  const metricUnitText = [row.metric_family, row.metric_name, row.unit].join(" ");
+  if (/(^|[_ -])(rate|share|percent|percentage|proportion)([_ -]|$)/i.test(metricUnitText)) {
+    if (/^(unknown|not_applicable|n\/a)$/i.test(clean(row.denominator))) {
+      error("T05_OBSERVATIONS", "RATE_DENOMINATOR_UNKNOWN", "observations", id, "A rate/share/percentage requires an identified denominator");
+    }
+    const ceiling = /percent|percentage|%/i.test(clean(row.unit)) ? 100 : 1;
+    for (const [field, value] of values) {
+      if (value !== null && Number.isFinite(value) && (value < 0 || value > ceiling)) {
+        error("T05_OBSERVATIONS", "RATE_OUT_OF_RANGE", "observations", id, `${field} is outside 0-${ceiling} for the stated unit`);
+      }
+    }
+  }
+  if (!isIsoDate(row.as_of_date)) error("T05_OBSERVATIONS", "OBSERVATION_DATE_INVALID", "observations", id, "as_of_date must be an ISO date");
+}
+
+// T06 — platform activity and delivery proxies are never relabelled as unique people or voters.
+const proxyMetric = /(views?|impressions?|accounts?|followers?|posts?|likes?|shares?|comments?|call_attempts?|completed_calls?|submitted_questions?|interactions?|engagements?)/i;
+const uniquePerson = /(unique[_ -]?(person|people|human|user|voter)|deduplicated[_ -]?(person|people|human|user|voter)|^people$|^voters?$)/i;
+for (const row of rows("observations")) {
+  const id = rowId(row, "observations");
+  const metricText = [row.metric_family, row.metric_name, row.unit].join(" ");
+  if (proxyMetric.test(metricText) && uniquePerson.test(clean(row.unique_entity_status))) {
+    error("T06_REACH_UNIQUENESS", "PROXY_AS_UNIQUE_PERSON", "observations", id, "A platform/delivery proxy is coded as unique people or voters");
+  }
+  if (
+    proxyMetric.test(metricText) &&
+    /\b(?:represents?|counts?|measures?|equals?|is|are)\s+(?:an?\s+)?(?:estimate of\s+)?unique\s+(?:people|persons|users|voters)\b/i.test(clean(row.limitations)) &&
+    !/\b(?:not|non-)\s*unique\s+(?:people|persons|users|voters)\b/i.test(clean(row.limitations))
+  ) {
+    error("T06_REACH_UNIQUENESS", "PROXY_LIMITATION_CONTRADICTION", "observations", id, "Limitations text affirmatively promotes a non-unique proxy to unique-person reach");
+  }
+}
+for (const row of rows("research_view")) {
+  const id = rowId(row, "research_view");
+  const caseObservations = rows("observations").filter((item) => clean(item.case_id) === clean(row.case_id));
+  const hasVerifiedUniquePeople = caseObservations.some((item) => uniquePerson.test(clean(item.unique_entity_status)) && !proxyMetric.test([item.metric_family, item.metric_name, item.unit].join(" ")));
+  if (/\b\d[\d,.+]*\s+(people|persons|users|voters)\b|\b(reached|exposed)\s+\d[\d,.+]*\s+(people|persons|users|voters)\b/i.test(clean(row.reach_summary)) && !hasVerifiedUniquePeople) {
+    error("T06_REACH_UNIQUENESS", "RESEARCH_VIEW_UNIQUE_REACH_UNSUPPORTED", "research_view", id, "Unique-person reach appears in the simple view without a qualifying observation");
+  }
+}
+
+// T07 — model tests retain their tested system, version, interface and causal scope.
+for (const row of rows("model_evaluations")) {
+  const id = rowId(row, "model_evaluations");
+  requireNonBlank(
+    row,
+    [
+      "evaluation_window", "election_or_context", "systems_tested", "versions_known", "interface",
+      "languages", "sample_unit", "design", "primary_metrics", "headline_results",
+      "causal_scope", "source_id", "data_availability", "notes"
+    ],
+    "T07_MODEL_EVALUATIONS", "model_evaluations", id
+  );
+  const sampleSize = parseNumber(row.sample_size);
+  if (isBlank(row.sample_size)) {
+    if (!/(sample|participant|question|prompt|benchmark|row count|output|denominator|experiment|not (?:reported|available|coded)|consult)/i.test([row.design, row.notes, row.data_availability].join(" "))) {
+      error("T07_MODEL_EVALUATIONS", "SAMPLE_SIZE_MISSING_UNEXPLAINED", "model_evaluations", id, "Blank sample_size requires a scoped sample/denominator explanation");
+    } else {
+      warn("T07_MODEL_EVALUATIONS", "SAMPLE_SIZE_NOT_STRUCTURED", "model_evaluations", id, "Sample size is not available as a structured integer; retain study-specific denominators before quantitative synthesis");
+    }
+  } else if (!Number.isInteger(sampleSize) || sampleSize <= 0) {
+    error("T07_MODEL_EVALUATIONS", "SAMPLE_SIZE_INVALID", "model_evaluations", id, "sample_size must be a positive integer for the stated sample unit");
+  }
+  if (/unknown/i.test(clean(row.versions_known)) && !/(unknown|not visible|not disclosed|unavailable|consumer|version)/i.test([row.notes, row.versions_known, row.causal_scope].join(" "))) {
+    error("T07_MODEL_EVALUATIONS", "UNKNOWN_VERSION_SCOPE_UNEXPLAINED", "model_evaluations", id, "Unknown versions must be explained in notes");
+  }
+  if (!/(not |no |point-in-time|capability|scope|limited|cannot|does not|may differ|laboratory|audit)/i.test(clean(row.causal_scope))) {
+    warn("T07_MODEL_EVALUATIONS", "CAUSAL_SCOPE_TOO_VAGUE", "model_evaluations", id, "causal_scope does not contain an explicit non-generalisation or design limitation");
+  }
+  if (/\b(changed|caused|determined|swung)\b.*\b(actual ballots?|observed votes?|turnout|aggregate election (?:result|outcome)|seats won)\b/i.test(clean(row.headline_results))) {
+    error("T07_MODEL_EVALUATIONS", "HEADLINE_CAUSAL_OVERCLAIM", "model_evaluations", id, "Headline results make an election-effect claim that a model evaluation cannot establish on its own");
+  }
+  const source = index.sources.get(clean(row.source_id));
+  if (source && !/(model_evaluation|research|scholarly|methodology|report|peer_reviewed|experiment|benchmark|audit)/i.test(clean(source.source_type))) {
+    warn("T07_MODEL_EVALUATIONS", "SOURCE_TYPE_UNEXPECTED", "model_evaluations", id, `Source type does not identify an evaluation or research record: ${clean(source.source_type)}`);
+  }
+}
+
+// T08 — the denominator of searched elections/regions is explicit and internally counted.
+const framesByRegion = new Map();
+const validSearchStatuses = new Set([
+  "complete", "systematic", "substantial", "partial", "partial_search_recorded", "ongoing", "not_started", "gap"
+]);
+const regionParent = (region) => {
+  if (["East Asia", "South Asia", "Southeast Asia", "Central Asia", "West Asia"].includes(region)) return "Asia";
+  if (["East Africa", "West Africa", "Southern Africa", "North Africa", "Central Africa"].includes(region)) return "Africa";
+  return region;
+};
+for (const row of rows("sampling_frame")) {
+  const id = rowId(row, "sampling_frame");
+  requireNonBlank(
+    row,
+    [
+      "region", "selection_basis", "search_status", "search_languages", "source_channels",
+      "included_case_count", "candidate_count", "negative_search_recorded", "known_gap", "last_searched"
+    ],
+    "T08_SAMPLING_FRAME", "sampling_frame", id
+  );
+  const region = clean(row.region);
+  if (framesByRegion.has(region)) {
+    error("T08_SAMPLING_FRAME", "REGION_DUPLICATE", "sampling_frame", id, `Duplicate sampling-frame region: ${region}`);
+  }
+  framesByRegion.set(region, row);
+  if (!validSearchStatuses.has(clean(row.search_status))) {
+    error("T08_SAMPLING_FRAME", "SEARCH_STATUS_INVALID", "sampling_frame", id, `Unknown search_status: ${clean(row.search_status)}`);
+  }
+  for (const field of ["included_case_count", "candidate_count"]) {
+    const number = parseNumber(row[field]);
+    if (!Number.isInteger(number) || number < 0) {
+      error("T08_SAMPLING_FRAME", "FRAME_COUNT_INVALID", "sampling_frame", id, `${field} must be a non-negative integer`);
+    }
+  }
+  if (!trueValues.has(lower(row.negative_search_recorded)) && !falseValues.has(lower(row.negative_search_recorded))) {
+    error("T08_SAMPLING_FRAME", "NEGATIVE_SEARCH_FLAG_INVALID", "sampling_frame", id, "negative_search_recorded must be an explicit boolean");
+  } else if (falseValues.has(lower(row.negative_search_recorded))) {
+    warn("T08_SAMPLING_FRAME", "NEGATIVE_SEARCH_NOT_RECORDED", "sampling_frame", id, "No negative/null search was recorded for this frame; prevalence inference is unsafe");
+  }
+  if (!isIsoDate(row.last_searched)) {
+    error("T08_SAMPLING_FRAME", "LAST_SEARCHED_INVALID", "sampling_frame", id, "last_searched must be an ISO date");
+  } else if (cutoff && clean(row.last_searched) > cutoff) {
+    error("T08_SAMPLING_FRAME", "LAST_SEARCHED_AFTER_CUTOFF", "sampling_frame", id, `last_searched is after dataset cutoff ${cutoff}`);
+  }
+  const actualCases = rows("cases").filter((item) => regionParent(clean(item.region)) === region).length;
+  const actualCandidates = rows("candidates").filter((item) => regionParent(clean(item.region)) === region).length;
+  if (parseNumber(row.included_case_count) !== actualCases) {
+    error("T08_SAMPLING_FRAME", "INCLUDED_COUNT_MISMATCH", "sampling_frame", id, `included_case_count=${clean(row.included_case_count)} but cases.csv has ${actualCases} for ${region}`);
+  }
+  if (parseNumber(row.candidate_count) !== actualCandidates) {
+    error("T08_SAMPLING_FRAME", "CANDIDATE_COUNT_MISMATCH", "sampling_frame", id, `candidate_count=${clean(row.candidate_count)} but candidates.csv has ${actualCandidates} for ${region}`);
+  }
+}
+for (const region of [...new Set([...rows("cases"), ...rows("candidates")].map((row) => regionParent(clean(row.region))).filter(Boolean))].sort()) {
+  if (!framesByRegion.has(region)) error("T08_SAMPLING_FRAME", "REGION_UNCOVERED", "sampling_frame", region, "Cases or candidates exist without a sampling-frame row");
+}
+if (rows("sampling_frame").length && !rows("sampling_frame").some((row) => trueValues.has(lower(row.negative_search_recorded)))) {
+  warn("T08_SAMPLING_FRAME", "NO_NEGATIVE_SEARCH_ANYWHERE", "sampling_frame", null, "The release records no systematic negative/null search in any sampling frame; incident prevalence claims remain unsupported");
+}
+
+// T09 — official election status is coherent with the release cutoff.
+const validElectionStatuses = new Set(["completed", "scheduled", "conditional"]);
+const officialDataStatuses = new Set(["current", "final", "pre_election", "scheduled", "not_yet_available"]);
+for (const row of rows("official_data_sources")) {
+  const id = rowId(row, "official_data_sources");
+  if (!officialDataStatuses.has(clean(row.data_status))) {
+    error("T09_OFFICIAL_ELECTION_STATUS", "OFFICIAL_SOURCE_STATUS_INVALID", "official_data_sources", id, `Unknown data_status: ${clean(row.data_status)}`);
+  }
+  if (!isIsoDate(row.retrieved_at)) {
+    error("T09_OFFICIAL_ELECTION_STATUS", "OFFICIAL_SOURCE_DATE_INVALID", "official_data_sources", id, "retrieved_at must be an ISO date");
+  } else if (cutoff && clean(row.retrieved_at) > cutoff) {
+    error("T09_OFFICIAL_ELECTION_STATUS", "OFFICIAL_SOURCE_AFTER_CUTOFF", "official_data_sources", id, `retrieved_at is after dataset cutoff ${cutoff}`);
+  }
+}
+for (const row of rows("official_elections")) {
+  const id = rowId(row, "official_elections");
+  if (!isIsoDate(row.election_date) || !isIsoDate(row.as_of_date)) {
+    error("T09_OFFICIAL_ELECTION_STATUS", "OFFICIAL_DATE_INVALID", "official_elections", id, "election_date and as_of_date must be ISO dates");
+  }
+  if (!validElectionStatuses.has(clean(row.election_status))) {
+    error("T09_OFFICIAL_ELECTION_STATUS", "ELECTION_STATUS_INVALID", "official_elections", id, `Unknown election_status: ${clean(row.election_status)}`);
+  }
+  const legalStatus = clean(row.legal_result_status);
+  if (!/^(not_yet_available|annulled|certified|final)$|(?:validated|confirmed|certified|final|void|annul|mandate|law_adopted)/i.test(legalStatus)) {
+    error("T09_OFFICIAL_ELECTION_STATUS", "LEGAL_STATUS_INVALID", "official_elections", id, `legal_result_status does not encode a recognized official chronology: ${legalStatus}`);
+  }
+  if (cutoff && clean(row.election_date) > cutoff && clean(row.election_status) === "completed") {
+    error("T09_OFFICIAL_ELECTION_STATUS", "FUTURE_ELECTION_COMPLETED", "official_elections", id, `Election is after dataset cutoff ${cutoff} but marked completed`);
+  }
+  if (cutoff && clean(row.election_date) <= cutoff && clean(row.election_status) !== "completed") {
+    warn("T09_OFFICIAL_ELECTION_STATUS", "PAST_ELECTION_NOT_COMPLETED", "official_elections", id, `Election is on/before dataset cutoff ${cutoff} but not marked completed`);
+  }
+}
+
+// T10 — turnout figures are numeric and arithmetically reconcilable.
+function optionalNonNegative(row, field, table, test) {
+  if (isBlank(row[field])) return null;
+  const value = parseNumber(row[field]);
+  if (!Number.isFinite(value) || value < 0) {
+    error(test, "NON_NEGATIVE_NUMBER_INVALID", table, rowId(row, table), `${field} must be a non-negative number when present`);
+    return null;
+  }
+  return value;
+}
+const turnoutByElection = new Map();
+for (const row of rows("official_turnout")) {
+  const id = rowId(row, "official_turnout");
+  requireNonBlank(row, ["electorate_measure", "participation_measure", "data_status", "official_source_id", "as_of_date"], "T10_TURNOUT", "official_turnout", id);
+  if (!officialDataStatuses.has(clean(row.data_status))) {
+    error("T10_TURNOUT", "TURNOUT_STATUS_INVALID", "official_turnout", id, `Unknown data_status: ${clean(row.data_status)}`);
+  }
+  const values = {};
+  for (const field of ["registered_voters", "ballots_cast", "valid_votes", "invalid_votes", "reporting_units_total", "reporting_units_counted"]) {
+    values[field] = optionalNonNegative(row, field, "official_turnout", "T10_TURNOUT");
+  }
+  if (loaded.get("official_turnout")?.headers.includes("turnout_numerator")) {
+    values.turnout_numerator = optionalNonNegative(row, "turnout_numerator", "official_turnout", "T10_TURNOUT");
+  }
+  if (values.reporting_units_total !== null && values.reporting_units_counted !== null && values.reporting_units_counted > values.reporting_units_total) {
+    error("T10_TURNOUT", "REPORTING_UNITS_EXCEED_TOTAL", "official_turnout", id, "reporting_units_counted exceeds reporting_units_total");
+  }
+  if (!isBlank(row.turnout_rate)) {
+    const rate = parseNumber(row.turnout_rate);
+    if (!Number.isFinite(rate) || rate < 0 || rate > 1) {
+      error("T10_TURNOUT", "TURNOUT_RATE_INVALID", "official_turnout", id, "turnout_rate must be between 0 and 1");
+    } else if (values.registered_voters > 0 && (values.turnout_numerator ?? values.ballots_cast) !== null) {
+      const numerator = values.turnout_numerator ?? values.ballots_cast;
+      const derived = numerator / values.registered_voters;
+      if (Math.abs(rate - derived) > 0.0001) {
+        error("T10_TURNOUT", "TURNOUT_RATE_DENOMINATOR_MISMATCH", "official_turnout", id, `turnout_rate=${rate} but stated turnout numerator/registered_voters=${derived}`);
+      }
+    }
+  }
+  if (values.ballots_cast !== null && values.valid_votes !== null && values.invalid_votes !== null) {
+    const derived = values.valid_votes + values.invalid_votes;
+    if (values.ballots_cast !== derived && !/(differ|reconcil|special ballot|blank vote)/i.test(clean(row.notes))) {
+      error("T10_TURNOUT", "BALLOT_ARITHMETIC", "official_turnout", id, `ballots_cast=${values.ballots_cast} but valid_votes+invalid_votes=${derived}; no reconciliation note`);
+    }
+  }
+  const election = index.official_elections.get(clean(row.election_id));
+  if (cutoff && election && clean(election.election_date) > cutoff && clean(row.data_status) === "final") {
+    error("T10_TURNOUT", "FUTURE_FINAL_TURNOUT", "official_turnout", id, "Future election has final turnout data");
+  }
+  if (!turnoutByElection.has(clean(row.election_id))) turnoutByElection.set(clean(row.election_id), []);
+  turnoutByElection.get(clean(row.election_id)).push(row);
+}
+
+// T11 — official result shares, totals and temporal status are coherent.
+const coverageStatuses = new Set(["complete", "complete_national_contest", "partial"]);
+const completeGroups = new Map();
+for (const row of rows("official_results")) {
+  const id = rowId(row, "official_results");
+  requireNonBlank(
+    row,
+    ["votes", "valid_vote_share", "result_status", "coverage_status", "official_source_id", "as_of_date"],
+    "T11_OFFICIAL_RESULTS", "official_results", id
+  );
+  const resultStatus = clean(row.result_status);
+  if (!/^(final|certified|annulled)$|(?:final|validat|confirm|certif|void|annul)/i.test(resultStatus)) {
+    error("T11_OFFICIAL_RESULTS", "RESULT_STATUS_INVALID", "official_results", id, `result_status does not encode a recognized official chronology: ${resultStatus}`);
+  }
+  if (!coverageStatuses.has(clean(row.coverage_status))) {
+    error("T11_OFFICIAL_RESULTS", "COVERAGE_STATUS_INVALID", "official_results", id, `Unknown coverage_status: ${clean(row.coverage_status)}`);
+  }
+  const votes = optionalNonNegative(row, "votes", "official_results", "T11_OFFICIAL_RESULTS");
+  const share = parseNumber(row.valid_vote_share);
+  if (!Number.isFinite(share) || share < 0 || share > 1) {
+    error("T11_OFFICIAL_RESULTS", "VOTE_SHARE_INVALID", "official_results", id, "valid_vote_share must be between 0 and 1");
+  }
+  const rank = parseNumber(row.rank);
+  if (!isBlank(row.rank) && (!Number.isInteger(rank) || rank <= 0)) {
+    error("T11_OFFICIAL_RESULTS", "RANK_INVALID", "official_results", id, "rank must be a positive integer when present");
+  }
+  if (isBlank(row.rank) && !/excluded|invalidated|withdrawn|not_ranked/i.test(clean(row.outcome))) {
+    error("T11_OFFICIAL_RESULTS", "RANK_MISSING", "official_results", id, "rank may be blank only for an explicitly excluded, invalidated, withdrawn or unranked option");
+  }
+  const election = index.official_elections.get(clean(row.election_id));
+  if (cutoff && election && clean(election.election_date) > cutoff) {
+    error("T11_OFFICIAL_RESULTS", "FUTURE_RESULT_ROW", "official_results", id, "Future election has an official result row");
+  }
+  if (["complete", "complete_national_contest"].includes(clean(row.coverage_status))) {
+    const key = [row.election_id, row.geographic_unit_type, row.geographic_unit_code, row.contest_name].map(clean).join("::");
+    if (!completeGroups.has(key)) completeGroups.set(key, []);
+    completeGroups.get(key).push({ row, votes, share });
+  }
+}
+const nationalCompleteGroupsByElection = new Map();
+for (const [key, group] of completeGroups) {
+  const shares = group.map((item) => item.share);
+  if (shares.every(Number.isFinite)) {
+    const total = shares.reduce((sum, value) => sum + value, 0);
+    if (Math.abs(total - 1) > 0.001) error("T11_OFFICIAL_RESULTS", "COMPLETE_SHARES_NOT_ONE", "official_results", key, `Complete-group shares sum to ${total}, not 1`);
+  }
+  if (clean(group[0].row.geographic_unit_type) === "national") {
+    const electionId = clean(group[0].row.election_id);
+    if (!nationalCompleteGroupsByElection.has(electionId)) nationalCompleteGroupsByElection.set(electionId, []);
+    nationalCompleteGroupsByElection.get(electionId).push(group);
+  }
+}
+for (const [electionId, groups] of nationalCompleteGroupsByElection) {
+  const nationalTurnouts = (turnoutByElection.get(electionId) || []).filter((row) => clean(row.geographic_unit_type) === "national" && !isBlank(row.valid_votes));
+  if (groups.length === 1 && nationalTurnouts.length === 1) {
+    const voteTotal = groups[0].reduce((sum, item) => sum + (item.votes ?? 0), 0);
+    const validVotes = parseNumber(nationalTurnouts[0].valid_votes);
+    if (Number.isFinite(validVotes) && voteTotal !== validVotes) {
+      error("T11_OFFICIAL_RESULTS", "RESULT_TURNOUT_TOTAL_MISMATCH", "official_results", electionId, `Complete national results total ${voteTotal}; official_turnout valid_votes=${validVotes}`);
+    }
+  } else if (groups.length > 1 && nationalTurnouts.length) {
+    warn("T11_OFFICIAL_RESULTS", "MULTIPLE_NATIONAL_CONTESTS", "official_results", electionId, "Multiple complete national contests prevent an automatic result-to-turnout total match");
+  }
+}
+
+// T12 — simple researcher view and coverage summaries reproduce the underlying rows.
+const researchViewKeys = new Set();
+for (const row of rows("research_view")) {
+  const id = rowId(row, "research_view");
+  requireNonBlank(
+    row,
+    [
+      "case_id", "pathway_id", "record_type", "manipulation_assessment", "controller",
+      "influence_vector", "target", "affected_agency", "agency_transfer_status",
+      "power_recipient", "evidence_strength"
+    ],
+    "T12_DERIVED_VIEWS", "research_view", id
+  );
+  const key = `${clean(row.case_id)}::${clean(row.pathway_id)}`;
+  if (researchViewKeys.has(key)) error("T12_DERIVED_VIEWS", "RESEARCH_VIEW_DUPLICATE", "research_view", id, `Duplicate case/pathway row: ${key}`);
+  researchViewKeys.add(key);
+  const parent = index.cases.get(clean(row.case_id));
+  const pathway = index.pathways.get(clean(row.pathway_id));
+  if (parent && clean(parent.record_type) !== clean(row.record_type)) {
+    error("T12_DERIVED_VIEWS", "VIEW_RECORD_TYPE_MISMATCH", "research_view", id, "record_type differs from cases.csv");
+  }
+  if (parent && clean(parent.manipulation_assessment) !== clean(row.manipulation_assessment)) {
+    error("T12_DERIVED_VIEWS", "VIEW_MANIPULATION_MISMATCH", "research_view", id, "manipulation_assessment differs from cases.csv");
+  }
+  if (pathway && clean(pathway.agency_transfer_status) !== clean(row.agency_transfer_status)) {
+    error("T12_DERIVED_VIEWS", "VIEW_AGENCY_STATUS_MISMATCH", "research_view", id, "agency_transfer_status differs from pathways.csv");
+  }
+}
+for (const row of rows("pathways")) {
+  const key = `${clean(row.case_id)}::${clean(row.pathway_id)}`;
+  if (!researchViewKeys.has(key)) error("T12_DERIVED_VIEWS", "PATHWAY_MISSING_FROM_VIEW", "research_view", clean(row.pathway_id), "Every pathway must appear once in research_view.csv");
+}
+const coverageRegions = new Set();
+for (const row of rows("coverage_summary")) {
+  const region = clean(row.region);
+  if (coverageRegions.has(region)) error("T12_DERIVED_VIEWS", "COVERAGE_REGION_DUPLICATE", "coverage_summary", region, "Duplicate coverage-summary region");
+  coverageRegions.add(region);
+  const actualCases = rows("cases").filter((item) => regionParent(clean(item.region)) === region).length;
+  const actualCandidates = rows("candidates").filter((item) => regionParent(clean(item.region)) === region).length;
+  const actualEvaluations = rows("case_catalog").filter(
+    (item) => clean(item.record_layer) === "empirical_model_study" && clean(item.region) === region
+  ).length;
+  if (parseNumber(row.included_case_count) !== actualCases) {
+    error("T12_DERIVED_VIEWS", "COVERAGE_CASE_COUNT_MISMATCH", "coverage_summary", region, `included_case_count differs from cases.csv (${actualCases})`);
+  }
+  if (parseNumber(row.candidate_count) !== actualCandidates) {
+    error("T12_DERIVED_VIEWS", "COVERAGE_CANDIDATE_COUNT_MISMATCH", "coverage_summary", region, `candidate_count differs from candidates.csv (${actualCandidates})`);
+  }
+  // model_evaluations stores country rather than region; only enforce a numeric count here.
+  const statedEvaluations = parseNumber(row.model_evaluation_count);
+  if (!Number.isInteger(statedEvaluations) || statedEvaluations < 0) {
+    error("T12_DERIVED_VIEWS", "COVERAGE_EVALUATION_COUNT_INVALID", "coverage_summary", region, "model_evaluation_count must be a non-negative integer");
+  } else if (statedEvaluations !== actualEvaluations) {
+    error("T12_DERIVED_VIEWS", "COVERAGE_EVALUATION_COUNT_MISMATCH", "coverage_summary", region, `model_evaluation_count differs from empirical-model rows in case_catalog.csv (${actualEvaluations})`);
+  }
+}
+
+// Normalized v0.3 joins must cover legacy pipe lists; this catches silent evidence loss.
+const evidencePairs = new Set(rows("claim_evidence").map((row) => `${clean(row.claim_id)}::${clean(row.source_id)}::${clean(row.relation)}`));
+const evidenceRelationsByClaimSource = new Map();
+for (const row of rows("claim_evidence")) {
+  const key = `${clean(row.claim_id)}::${clean(row.source_id)}`;
+  if (!evidenceRelationsByClaimSource.has(key)) evidenceRelationsByClaimSource.set(key, new Set());
+  evidenceRelationsByClaimSource.get(key).add(clean(row.relation));
+}
+for (const claim of rows("claims")) {
+  for (const sourceId of ids(claim.source_ids)) {
+    const prefix = `${clean(claim.claim_id)}::${sourceId}::`;
+    if (![...evidencePairs].some((pair) => pair.startsWith(prefix))) {
+      error("T03_FOREIGN_KEYS", "CLAIM_EVIDENCE_JOIN_MISSING", "claim_evidence", clean(claim.claim_id), `Supporting source is absent from normalized join: ${sourceId}`);
+    }
+  }
+  for (const sourceId of ids(claim.counter_source_ids)) {
+    const relations = evidenceRelationsByClaimSource.get(`${clean(claim.claim_id)}::${sourceId}`) || new Set();
+    if (![...relations].some((relation) => /counter|qualif/i.test(relation))) {
+      error("T03_FOREIGN_KEYS", "COUNTEREVIDENCE_JOIN_MISSING", "claim_evidence", clean(claim.claim_id), `Counter-source is absent or not labelled counterevidence: ${sourceId}`);
+    }
+  }
+}
+
+// Reciprocity between the normalized case-election join and the legacy official link list.
+const normalizedCaseElections = new Set(rows("case_elections").map((row) => `${clean(row.case_id)}::${clean(row.election_id)}`));
+for (const election of rows("official_elections")) {
+  for (const caseId of ids(election.linked_case_ids)) {
+    const pair = `${caseId}::${clean(election.election_id)}`;
+    if (!normalizedCaseElections.has(pair)) {
+      error("T03_FOREIGN_KEYS", "CASE_ELECTION_JOIN_MISSING", "case_elections", pair, "Official linked_case_ids entry is absent from case_elections.csv");
+    }
+  }
+}
+for (const row of rows("case_elections")) {
+  const election = index.official_elections.get(clean(row.election_id));
+  if (election && !ids(election.linked_case_ids).includes(clean(row.case_id))) {
+    error("T03_FOREIGN_KEYS", "CASE_ELECTION_NOT_RECIPROCAL", "case_elections", rowId(row, "case_elections"), "Normalized join is absent from official_elections.linked_case_ids");
+  }
+}
+for (const caseRow of rows("cases")) {
+  if (![...normalizedCaseElections].some((pair) => pair.startsWith(`${clean(caseRow.case_id)}::`))) {
+    error("T03_FOREIGN_KEYS", "CASE_WITHOUT_ELECTION", "case_elections", clean(caseRow.case_id), "Every case must link to at least one official election/context row");
+  }
+}
+
+function stableIssueOrder(a, b) {
+  return (
+    a.test.localeCompare(b.test) ||
+    a.code.localeCompare(b.code) ||
+    String(a.table).localeCompare(String(b.table)) ||
+    String(a.row_id).localeCompare(String(b.row_id)) ||
+    a.message.localeCompare(b.message)
+  );
+}
+blocking.sort(stableIssueOrder);
+advisory.sort(stableIssueOrder);
+
+const tableCounts = Object.fromEntries([...loaded.entries()].map(([name, table]) => [name, table.rows.length]));
+const report = {
+  auditor: "agency-transfer-election-cases-v0.3.0/audit-v03",
+  cutoff,
+  status: blocking.length ? "fail" : "pass",
+  summary: {
+    error_count: blocking.length,
+    warning_count: advisory.length,
+    table_row_counts: tableCounts
+  },
+  errors: blocking,
+  warnings: advisory
+};
+
+process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+if (blocking.length) process.exitCode = 1;

scripts/build-data.mjs

@@ -9,14 +9,29 @@ const seedPath = path.join(root, "research", "seed.json");
 const candidatesPath = path.join(root, "research", "candidates.json");
 const europeCandidatesPath = path.join(root, "research", "europe_candidates.json");
 const officialElectoralDataPath = path.join(root, "research", "official_electoral_data.json");
+const extensionsPath = path.join(root, "research", "v0.3_extensions.json");
 const outDir = path.join(root, "data");
 const seed = JSON.parse(fs.readFileSync(seedPath, "utf8"));
 const officialElectoralData = JSON.parse(fs.readFileSync(officialElectoralDataPath, "utf8"));
+const extensions = JSON.parse(fs.readFileSync(extensionsPath, "utf8"));
 seed.candidates = [
   ...JSON.parse(fs.readFileSync(candidatesPath, "utf8")),
-  ...JSON.parse(fs.readFileSync(europeCandidatesPath, "utf8"))
+  ...JSON.parse(fs.readFileSync(europeCandidatesPath, "utf8")),
+  ...extensions.additional_candidates
 ];
 Object.assign(seed, officialElectoralData);
+seed.cases = [...seed.cases, ...extensions.additional_cases].map((row) => ({
+  ...row,
+  ...(extensions.case_metadata[row.case_id] || {})
+}));
+seed.claims = [...seed.claims, ...extensions.additional_claims];
+seed.sources = [...seed.sources, ...extensions.additional_sources];
+seed.events = [...seed.events, ...extensions.additional_events];
+seed.case_sources = [...seed.case_sources, ...extensions.additional_case_sources];
+const usElection = seed.official_elections.find((row) => row.election_id === "elec-us-midterms-2026");
+if (usElection && !usElection.linked_case_ids.includes("us-ca11-2026-wiener-conniechan-chatbot")) {
+  usElection.linked_case_ids += "|us-ca11-2026-wiener-conniechan-chatbot";
+}
 seed.events = [...seed.events].sort(
   (a, b) => a.event_date.localeCompare(b.event_date) || a.event_id.localeCompare(b.event_id)
 );
@@ -25,7 +40,8 @@ const schemas = {
   cases: [
     "case_id", "case_family_id", "title", "country", "iso3", "region",
     "election_name", "election_type", "election_date_start", "election_date_end",
-    "case_status", "as_of_date", "anchor_case", "summary", "actor_controlling_system",
+    "case_status", "as_of_date", "anchor_case", "record_type", "manipulation_assessment",
+    "summary", "actor_controlling_system",
     "actor_type", "actor_attribution_status", "target_population", "influence_vector",
     "platforms", "mechanism_class", "ai_role", "generative_ai_status",
     "affected_state", "agency_transfer_path", "power_concentrated_in", "democratic_harm",
@@ -36,13 +52,14 @@ const schemas = {
   ],
   claims: [
     "claim_id", "case_id", "claim_type", "claim_text", "evidence_label",
-    "confidence", "source_ids", "counter_source_ids", "notes", "review_status",
-    "verified_at"
+    "confidence", "coder_confidence_in_label", "claim_status", "evidence_strength",
+    "source_ids", "counter_source_ids", "notes", "review_status", "verified_at"
   ],
   sources: [
     "source_id", "title", "publisher", "author", "publication_date", "url",
     "source_type", "primary_secondary", "jurisdiction", "language",
-    "source_quality", "retrieved_at", "notes"
+    "source_quality", "source_independence", "method_transparency", "access_status",
+    "archive_url", "content_hash", "retrieved_at", "notes"
   ],
   events: [
     "event_id", "case_id", "event_date", "event_type", "description",
@@ -72,24 +89,433 @@ const schemas = {
   official_turnout: [
     "turnout_id", "election_id", "geographic_unit_type", "geographic_unit_code",
     "geographic_unit_name", "data_status", "electorate_measure", "participation_measure",
-    "registered_voters", "ballots_cast",
+    "registered_voters", "ballots_cast", "turnout_numerator", "turnout_numerator_measure",
+    "authority_reported_turnout_rate",
     "valid_votes", "invalid_votes", "turnout_rate", "reporting_units_total",
     "reporting_units_counted", "official_source_id", "as_of_date", "notes"
   ],
   official_results: [
     "result_id", "election_id", "geographic_unit_type", "geographic_unit_code",
     "geographic_unit_name", "contest_name", "candidate_or_option",
-    "party_or_affiliation", "votes", "valid_vote_share", "rank", "outcome",
+    "party_or_affiliation", "ballot_designating_entity", "votes", "valid_vote_share", "rank", "outcome", "seats",
     "result_status", "coverage_status", "official_source_id", "as_of_date", "notes"
   ],
   official_data_sources: [
     "official_source_id", "case_family_id", "jurisdiction", "electoral_institution",
     "title", "url", "dataset_role", "data_status", "format",
     "geographic_granularity", "access_method", "update_frequency",
-    "license_or_terms", "retrieved_at", "notes"
+    "license_or_terms", "landing_url", "download_url", "published_or_updated_at",
+    "retrieved_at", "content_sha256", "content_bytes", "source_schema_version",
+    "snapshot_cutoff", "notes"
+  ],
+  official_election_metrics: [
+    "metric_id", "election_id", "geographic_unit_type", "geographic_unit_code",
+    "metric_code", "value", "source_field_code", "source_label_original",
+    "numerator_metric", "denominator_metric", "authority_reported_rate", "computed_rate",
+    "legal_role", "data_status", "official_source_id", "as_of_date", "notes"
+  ],
+  research_view: [
+    "pathway_id", "case_id", "case_title", "country", "election_date", "record_type",
+    "case_status", "manipulation_assessment", "generative_ai_status", "ai_role",
+    "system_or_model", "controller", "influence_vector", "target", "affected_agency",
+    "agency_transfer_status", "power_recipient", "reach_summary", "behavioural_effect",
+    "electoral_effect", "evidence_strength", "main_uncertainty", "last_verified"
+  ],
+  case_catalog: [
+    "catalog_id", "record_layer", "record_type", "title", "country", "region",
+    "election_name", "election_date", "case_status", "manipulation_assessment",
+    "ai_role", "generative_ai_status", "evidence_maturity", "incident_count_eligible",
+    "research_status", "source_count_or_links", "main_caveat", "last_checked"
+  ],
+  case_actors: [
+    "case_actor_id", "case_id", "actor_name", "actor_role", "actor_type",
+    "attribution_status", "control_dimension", "source_claim_ids", "notes"
+  ],
+  technology_uses: [
+    "tech_use_id", "case_id", "provider", "product_or_model", "version",
+    "access_type", "technology_role", "use_status", "provenance_status",
+    "evidence_label", "source_claim_ids", "notes"
+  ],
+  content_items: [
+    "content_item_id", "case_id", "title", "media_type", "represented_person",
+    "communication_goal", "representation_mode", "ai_disclosure", "authorization_status",
+    "disclosure_salience", "presentation_mode", "source_claim_ids", "notes"
+  ],
+  pathways: [
+    "pathway_id", "case_id", "affected_agency", "control_shift_from", "control_shift_to",
+    "mechanism", "opacity", "personalization", "contestability", "duration",
+    "power_recipient", "harm_pathway", "observed_outcome", "agency_transfer_status",
+    "assessment_label", "source_claim_ids", "reviewer_note"
+  ],
+  observations: [
+    "observation_id", "case_id", "pathway_id", "claim_id", "metric_family", "metric_name",
+    "value_low", "value_best", "value_high", "value_operator", "unit", "denominator",
+    "unique_entity_status", "platform", "geographic_scope", "measurement_window",
+    "measurement_method", "causal_status", "source_id", "as_of_date", "limitations"
+  ],
+  model_evaluations: [
+    "evaluation_id", "title", "country", "evaluation_window", "election_or_context",
+    "systems_tested", "versions_known", "interface", "languages", "sample_unit",
+    "sample_size", "design", "primary_metrics", "headline_results", "causal_scope",
+    "source_id", "data_availability", "notes"
+  ],
+  claim_evidence: [
+    "claim_evidence_id", "claim_id", "source_id", "relation", "evidence_scope",
+    "directness", "locator", "extracted_at"
+  ],
+  analytic_record_claims: [
+    "record_claim_id", "record_type", "record_id", "case_id", "claim_id", "relation"
+  ],
+  case_elections: [
+    "case_election_id", "case_id", "election_id", "relation"
+  ],
+  election_sources: [
+    "election_source_id", "election_id", "official_source_id", "source_role"
+  ],
+  sampling_frame: [
+    "frame_id", "region", "selection_basis", "search_status", "search_languages",
+    "source_channels", "included_case_count", "candidate_count", "negative_search_recorded",
+    "known_gap", "last_searched"
+  ],
+  coverage_summary: [
+    "region", "included_case_count", "candidate_count", "model_evaluation_count", "coverage_note"
   ]
 };
 
+function rowsFromArrays(rows, columns) {
+  return rows.map((values) => Object.fromEntries(columns.map((column, index) => [column, values[index] ?? ""])));
+}
+
+function appendPipe(value, item) {
+  const items = new Set(String(value || "").split("|").filter(Boolean));
+  items.add(item);
+  return [...items].join("|");
+}
+
+function regionForCountry(country) {
+  const map = {
+    Romania: "Europe", Moldova: "Europe", Hungary: "Europe", "United Kingdom": "Europe",
+    "European Union": "Europe", Brazil: "South America", Colombia: "South America",
+    Ecuador: "South America", Canada: "North America", "United States": "North America",
+    Japan: "Asia", Australia: "Oceania", Poland: "Europe"
+  };
+  if (String(country).includes("|")) return "Cross-national";
+  return map[country] || "Other";
+}
+
+function canonicalRegion(region) {
+  if (["East Asia", "South Asia", "Southeast Asia", "Central Asia", "West Asia"].includes(region)) return "Asia";
+  if (["East Africa", "West Africa", "Southern Africa", "North Africa", "Central Africa"].includes(region)) return "Africa";
+  return region;
+}
+
+const additionalOfficialSources = [
+  ["off-ro-2024-ccr-h31", "romania-presidential-2024-2025", "Romania", "Constitutional Court of Romania", "Decision 31 of 2 December 2024 confirming and validating the first-round result", "https://legislatie.just.ro/public/DetaliiDocument/291969", "legal_validation_and_complete_results", "final", "HTML legal record", "national", "landing page", "finalized election record", "official legal record", "2026-08-12", "H31 established the valid first-round order before H32 later voided the entire process."],
+  ["off-ro-2025-ccr-h39", "romania-presidential-2024-2025", "Romania", "Constitutional Court of Romania", "Decision 39 of 9 May 2025 confirming and validating the repeat first round", "https://www.ccr.ro/wp-content/uploads/2025/05/Hotarare_39_2025.pdf", "legal_validation_and_complete_results", "final", "PDF", "national", "direct download", "finalized election record", "official legal record", "2026-08-12", "Complete 11-candidate result."],
+  ["off-ro-2025-ccr-h43", "romania-presidential-2024-2025", "Romania", "Constitutional Court of Romania", "Decision 43 of 22 May 2025 confirming and validating the second round", "https://www.ccr.ro/wp-content/uploads/2025/05/Hotarare_43_2025.pdf", "legal_validation", "final", "PDF", "national", "direct download", "finalized election record", "official legal record", "2026-08-12", "Second-round confirmation."],
+  ["off-ro-2025-ccr-h44", "romania-presidential-2024-2025", "Romania", "Constitutional Court of Romania", "Decision 44 of 22 May 2025 validating the election of Nicușor Dan", "https://www.ccr.ro/wp-content/uploads/2025/05/Hotarare_44_2025.pdf", "winner_validation", "final", "PDF", "national", "direct download", "finalized election record", "official legal record", "2026-08-12", "Validation of president-elect."],
+  ["off-md-2024-ref-cc-h24", "moldova-elections-2024-2025", "Moldova", "Constitutional Court of Moldova", "Decision 24 confirming the 2024 constitutional referendum", "https://constcourt.md/ccdocview.php?docid=866&l=ro&tip=hotariri", "legal_validation_and_turnout_definition", "final", "HTML legal record", "national", "landing page", "finalized election record", "official legal record", "2026-08-12", "Defines the referendum validity calculation and confirms adoption."],
+  ["off-md-2024-pres-cc-h25", "moldova-elections-2024-2025", "Moldova", "Constitutional Court of Moldova", "Decision 25 confirming the 2024 presidential election", "https://constcourt.md/ccdocview.php?docid=867&l=ro&tip=hotariri", "legal_validation_complete_results_and_turnout_definition", "final", "HTML legal record", "national", "landing page", "finalized election record", "official legal record", "2026-08-12", "Distinguishes protocol fields C and D and confirms both rounds."],
+  ["off-md-2025-cec-h4149", "moldova-elections-2024-2025", "Moldova", "Central Electoral Commission of Moldova", "Decision 4149 centralizing the 28 September 2025 parliamentary results", "https://a.cec.md/index.php/ro/cu-privire-la-centralizarea-rezultatelor-alegerilor-parlamentare-din-28-septembr-2751_115473.html", "turnout_and_complete_results_landing", "final", "HTML with attachments", "national and precinct", "landing page", "finalized election record", "official record", "2026-08-12", "Pairs the opaque workbook download with its decision page."],
+  ["off-md-2025-cec-h4151", "moldova-elections-2024-2025", "Moldova", "Central Electoral Commission of Moldova", "Decision 4151 allocating parliamentary mandates", "https://a.cec.md/index.php/ro/cu-privire-la-atribuirea-mandatelor-de-deputat-in-parlamentul-republicii-2751_115476.html", "seat_allocation", "final", "HTML with attachments", "national", "landing page", "finalized election record", "official record", "2026-08-12", "Official seat allocation."],
+  ["off-md-2025-cc-h12", "moldova-elections-2024-2025", "Moldova", "Constitutional Court of Moldova", "Decision 12 of 16 October 2025 confirming legality and validating 101 mandates", "https://constcourt.md/ccdocview.php?docid=882&l=ro&tip=hotariri", "legal_validation_and_mandates", "final", "HTML legal record", "national", "landing page", "finalized election record", "official legal record", "2026-08-12", "Confirms the election and validates 101 mandates."],
+  ["off-br-2026-contests", "brazil-general-2026", "Brazil", "Superior Electoral Court", "Resolution 23.751/2026 on offices contested and voting rules", "https://www.tse.jus.br/legislacao/compilada/res/2026/resolucao-no-23-751-de-26-de-fevereiro-de-2026", "contest_definition", "current", "HTML legal record", "national and state", "landing page", "election cycle", "official legal record", "2026-08-12", "Second round applies only to president and governors when required."],
+  ["off-us-congress-election-law", "us-midterms-2026", "United States", "United States Congress", "2 U.S.C. sections 1 and 7: congressional election timing", "https://uscode.house.gov/view.xhtml?edition=prelim&num=0&req=granuleid%3AUSC-prelim-title2-section7", "contest_timing_context", "current", "HTML legal code", "federal and state/district", "landing page", "statutory", "public law", "2026-08-12", "The national date bundles separate House, Senate and special contests administered and certified by states."],
+  ["off-nh-2024-primary-law", "new-hampshire-biden-robocall-2024", "New Hampshire", "New Hampshire General Court", "RSA 659:73 and RSA 654:34 primary counting and undeclared-voter context", "https://gc.nh.gov/rsa/html/LXIII/659/659-73.htm", "denominator_and_counting_context", "current", "HTML legal code", "state", "landing page", "statutory", "public law", "2026-08-12", "Explains why the all-party checklist is not a Democratic-primary turnout denominator."]
+].map((values) => {
+  const oldColumns = ["official_source_id", "case_family_id", "jurisdiction", "electoral_institution", "title", "url", "dataset_role", "data_status", "format", "geographic_granularity", "access_method", "update_frequency", "license_or_terms", "retrieved_at", "notes"];
+  const row = Object.fromEntries(oldColumns.map((column, index) => [column, values[index] ?? ""]));
+  return { ...row, landing_url: row.url, download_url: /direct download/i.test(row.access_method) ? row.url : "", published_or_updated_at: "", content_sha256: "", content_bytes: "", source_schema_version: "", snapshot_cutoff: "2026-08-12" };
+});
+seed.official_data_sources.push(...additionalOfficialSources);
+seed.official_data_sources = seed.official_data_sources.map((row) => ({
+  ...row,
+  landing_url: row.landing_url || row.url,
+  download_url: row.download_url || (/direct download/i.test(row.access_method || "") ? row.url : ""),
+  published_or_updated_at: row.published_or_updated_at || "",
+  content_sha256: row.content_sha256 || "",
+  content_bytes: row.content_bytes || "",
+  source_schema_version: row.source_schema_version || "",
+  snapshot_cutoff: row.snapshot_cutoff || "2026-08-12"
+}));
+
+const officialSourceById = new Map(seed.official_data_sources.map((row) => [row.official_source_id, row]));
+const oldH32 = officialSourceById.get("off-ro-2024-ccr-annulment");
+if (oldH32) {
+  oldH32.url = "https://legislatie.just.ro/Public/DetaliiDocumentAfis/292099";
+  oldH32.title = "Decision 32 of 6 December 2024 voiding the entire presidential electoral process";
+}
+
+for (const election of seed.official_elections) {
+  if (election.election_id === "elec-ro-pres-2024-r1") {
+    election.legal_result_status = "validated_then_void";
+    election.official_source_ids = appendPipe(election.official_source_ids, "off-ro-2024-ccr-h31");
+    election.notes = "H31 first confirmed and validated the final first-round tally; H32 subsequently voided the entire process. Preserve final tally, validation, and process status separately.";
+  }
+  if (election.election_id === "elec-ro-pres-2025-r1") {
+    election.legal_result_status = "CCR_confirmed_and_validated_2025-05-09";
+    election.official_source_ids = appendPipe(election.official_source_ids, "off-ro-2025-ccr-h39");
+  }
+  if (election.election_id === "elec-ro-pres-2025-r2") {
+    election.legal_result_status = "CCR_confirmed_and_president_elected_2025-05-22";
+    election.official_source_ids = appendPipe(appendPipe(election.official_source_ids, "off-ro-2025-ccr-h43"), "off-ro-2025-ccr-h44");
+  }
+  if (election.election_id === "elec-md-pres-2024-r1" || election.election_id === "elec-md-pres-2024-r2") {
+    election.legal_result_status = "CEC_final_and_Constitutional_Court_confirmed";
+    election.official_source_ids = appendPipe(election.official_source_ids, "off-md-2024-pres-cc-h25");
+  }
+  if (election.election_id === "elec-md-referendum-2024") {
+    election.legal_result_status = "law_adopted_and_Constitutional_Court_confirmed";
+    election.official_source_ids = appendPipe(election.official_source_ids, "off-md-2024-ref-cc-h24");
+    election.notes = "Question: Susțineți modificarea Constituției în vederea aderării Republicii Moldova la Uniunea Europeană? Validity threshold: one third; law adopted and confirmed.";
+  }
+  if (election.election_id === "elec-md-parl-2025") {
+    election.legal_result_status = "CEC_valid_Constitutional_Court_confirmed_101_mandates";
+    election.official_source_ids = appendPipe(appendPipe(appendPipe(election.official_source_ids, "off-md-2025-cec-h4149"), "off-md-2025-cec-h4151"), "off-md-2025-cc-h12");
+  }
+  if (election.election_id === "elec-br-general-2026-r1") {
+    election.contest_type = "election_bundle";
+    election.election_name = "Brazil 2026 first-round election bundle";
+    election.official_source_ids = appendPipe(election.official_source_ids, "off-br-2026-contests");
+    election.notes = "4 October bundles president, 27 governors, two Senate choices per elector, Chamber of Deputies, state assemblies and the Federal District chamber. Candidate files before the 15 August filing deadline are incomplete snapshots, not ballot qualification.";
+  }
+  if (election.election_id === "elec-br-general-2026-r2") {
+    election.contest_type = "conditional_executive_runoffs";
+    election.election_name = "Brazil 2026 conditional presidential and gubernatorial runoffs";
+    election.official_source_ids = appendPipe(election.official_source_ids, "off-br-2026-contests");
+    election.notes = "25 October is limited to president and governors requiring a runoff; it is not a second round for legislative contests.";
+  }
+  if (election.election_id === "elec-us-midterms-2026") {
+    election.contest_type = "election_bundle";
+    election.round = "varies_by_jurisdiction";
+    election.election_name = "United States 2026 federal election bundle";
+    election.administering_authority = "state and local election authorities; no single national certifier";
+    election.official_source_ids = appendPipe(election.official_source_ids, "off-us-congress-election-law");
+    election.notes = "Not one national contest: 435 House districts, Senate Class II and special/delegate contests are administered and certified by states; some jurisdictions can hold later runoffs. FEC files are calendar/finance snapshots, not ballot-access or result certification.";
+  }
+}
+
+const mdTurnout = {
+  "turnout-md-2024-r1-national": { A: 2710856, B: 312650, C: 1564758, D: 1564495, E: 263, F: 18464, H: 1546031, rate: 0.517530972322, reported: 0.5175, numerator: "C", source: "off-md-2024-pres-cc-h25", note: "The protocol distinguishes voters receiving ballots (C) from voters participating (D); the Constitutional Court applied C/(A+B) to the one-third validity threshold." },
+  "turnout-md-2024-referendum-national": { A: 2711615, B: 309199, C: 1532264, D: 1531392, E: 872, F: 42518, H: 1488874, rate: 0.507235466997, reported: 0.5072, numerator: "C", source: "off-md-2024-ref-cc-h24", note: "The protocol distinguishes voters receiving ballots (C) from voters participating (D); the Constitutional Court applied C/(A+B) to the one-third validity threshold." },
+  "turnout-md-2024-r2-national": { A: 2709867, B: 423820, C: 1701333, D: 1701284, E: 49, F: 20715, H: 1680569, rate: 0.542917336671, reported: 0.5429, numerator: "C", source: "off-md-2024-pres-cc-h25", note: "The protocol distinguishes voters receiving ballots (C) from voters participating (D); the Constitutional Court applied C/(A+B) to the one-fifth validity threshold." },
+  "turnout-md-2025-parliament-national": { A: 2738735, B: 342244, C: 1609715, D: 1609579, E: 136, F: 30857, H: 1578722, I: 3662273, J: 2052558, rate: 0.522424528048, reported: 0.5224, numerator: "D", source: "off-md-2025-cec-h4149", note: "CEC declared the election valid on 5 October 2025; the Constitutional Court confirmed legality and 101 mandates on 16 October. For this election the official 52.24% rate uses D/(A+B)." }
+};
+for (const row of seed.official_turnout) {
+  row.turnout_numerator = row.ballots_cast;
+  row.turnout_numerator_measure = row.participation_measure;
+  row.authority_reported_turnout_rate = row.turnout_rate;
+  const exact = mdTurnout[row.turnout_id];
+  if (exact) {
+    row.electorate_measure = "post-election protocol fields A+B: basic-list plus supplementary-list electors; not a conventional fixed ex-ante register";
+    row.participation_measure = "protocol field D: voters who participated";
+    row.registered_voters = exact.A + exact.B;
+    row.ballots_cast = exact.D;
+    row.turnout_numerator = exact[exact.numerator];
+    row.turnout_numerator_measure = `protocol field ${exact.numerator}: ${exact.numerator === "C" ? "voters receiving ballots" : "voters who participated"}`;
+    row.valid_votes = exact.H;
+    row.invalid_votes = exact.F;
+    row.turnout_rate = exact.rate;
+    row.authority_reported_turnout_rate = exact.reported;
+    row.notes = `${exact.note} C=${exact.C}; D=${exact.D}; E=C-D=${exact.E}.`;
+  }
+  if (row.turnout_id === "turnout-nh-2024-dem-primary-state") {
+    row.notes += " Official contest votes were 123,996, leaving a 1,815 ballot-minus-contest-vote gap that the source does not classify as invalid or undervote.";
+  }
+  if (row.turnout_id === "electorate-br-2026-audited-national") {
+    row.electorate_measure = "official eligible electorate published by TSE after registration closed";
+  }
+}
+
+const metricRows = [];
+function addMetric(electionId, geoType, geoCode, code, value, sourceCode, label, numerator, denominator, reported, computed, legalRole, status, sourceId, notes = "") {
+  metricRows.push({ metric_id: `metric-${electionId}-${code.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-")}`, election_id: electionId, geographic_unit_type: geoType, geographic_unit_code: geoCode, metric_code: code, value, source_field_code: sourceCode, source_label_original: label, numerator_metric: numerator, denominator_metric: denominator, authority_reported_rate: reported, computed_rate: computed, legal_role: legalRole, data_status: status, official_source_id: sourceId, as_of_date: "2026-08-12", notes });
+}
+for (const row of seed.official_turnout.filter((item) => !mdTurnout[item.turnout_id])) {
+  if (row.registered_voters !== "") addMetric(row.election_id, row.geographic_unit_type, row.geographic_unit_code, "registered_voters", row.registered_voters, "", row.electorate_measure, "", "", "", "", "context_or_denominator", row.data_status, row.official_source_id, row.notes);
+  if (row.ballots_cast !== "") addMetric(row.election_id, row.geographic_unit_type, row.geographic_unit_code, "ballots_cast", row.ballots_cast, "", row.participation_measure, "", "", "", "", "participation", row.data_status, row.official_source_id, row.notes);
+  if (row.valid_votes !== "") addMetric(row.election_id, row.geographic_unit_type, row.geographic_unit_code, "valid_votes", row.valid_votes, "", "valid contest votes", "", "", "", "", "result_denominator", row.data_status, row.official_source_id);
+  if (row.turnout_rate !== "") addMetric(row.election_id, row.geographic_unit_type, row.geographic_unit_code, "turnout_rate", row.turnout_rate, "", "turnout rate", "turnout_numerator", "registered_voters", row.authority_reported_turnout_rate, row.turnout_rate, "reported_participation_rate", row.data_status, row.official_source_id, row.notes);
+}
+for (const row of seed.official_turnout.filter((item) => mdTurnout[item.turnout_id])) {
+  const m = mdTurnout[row.turnout_id];
+  const labels = { A: "electors on basic lists", B: "electors on supplementary lists", C: "electors who received ballots", D: "electors who participated", E: "received ballots minus participated", F: "invalid ballots", H: "valid votes", I: "printed ballots", J: "unused and cancelled ballots" };
+  for (const code of ["A", "B", "C", "D", "E", "F", "H", "I", "J"]) {
+    if (m[code] !== undefined) addMetric(row.election_id, row.geographic_unit_type, row.geographic_unit_code, code, m[code], code, labels[code], "", "", "", "", code === m.numerator ? "legal_turnout_numerator" : "protocol_component", row.data_status, m.source, row.notes);
+  }
+  addMetric(row.election_id, row.geographic_unit_type, row.geographic_unit_code, "A_plus_B", m.A + m.B, "A+B", "post-election protocol denominator", "", "", "", "", "legal_turnout_denominator", row.data_status, m.source, row.notes);
+  addMetric(row.election_id, row.geographic_unit_type, row.geographic_unit_code, "legal_turnout_rate", m.rate, "", "legal turnout rate", m.numerator, "A+B", m.reported, m.rate, "legal_validity_rate", row.data_status, m.source, row.notes);
+  addMetric(row.election_id, row.geographic_unit_type, row.geographic_unit_code, "participation_rate_D", m.D / (m.A + m.B), "", "D/(A+B)", "D", "A+B", m.numerator === "D" ? m.reported : "", m.D / (m.A + m.B), "descriptive_participation_rate", row.data_status, m.source, row.notes);
+}
+addMetric("elec-us-nh-dem-primary-2024", "state", "US-NH", "presidential_contest_votes", 123996, "", "votes counted for the Democratic presidential contest", "", "", "", "", "contest_total", "final", "off-nh-2024-dem-results", "The 1,815 gap from Democratic ballots cast is not classified by the source.");
+addMetric("elec-us-nh-dem-primary-2024", "state", "US-NH", "ballot_minus_contest_vote_gap", 1815, "", "Democratic ballots cast minus presidential contest votes", "", "", "", "", "unclassified_gap", "final", "off-nh-2024-dem-results", "Do not relabel as invalid or undervote without an official classification.");
+seed.official_election_metrics = metricRows;
+
+const resultTotals = { "elec-ro-pres-2024-r1": 9242186, "elec-ro-pres-2025-r1": 9430274, "elec-md-pres-2024-r1": 1546031, "elec-md-parl-2025": 1578722 };
+for (const row of seed.official_results) {
+  row.ballot_designating_entity = row.ballot_designating_entity || "";
+  row.seats = row.seats ?? "";
+  if (["elec-ro-pres-2024-r1", "elec-ro-pres-2025-r1", "elec-md-pres-2024-r1", "elec-md-parl-2025"].includes(row.election_id)) row.coverage_status = "complete_national_contest";
+  if (row.election_id === "elec-ro-pres-2024-r1") row.result_status = "final_tally_validated_then_process_void";
+  if (row.election_id === "elec-ro-pres-2025-r1") row.result_status = "CCR_confirmed_and_validated";
+  if (row.election_id === "elec-ro-pres-2025-r2") row.result_status = "CCR_confirmed_and_validated";
+  if (row.election_id.startsWith("elec-md-")) row.result_status = "CEC_final_and_Constitutional_Court_confirmed";
+  if (row.result_id === "result-md24r1-maia-sandu") { row.party_or_affiliation = ""; row.ballot_designating_entity = "PAS"; }
+  if (row.result_id === "result-md24r1-alexandr-stoianoglo") { row.party_or_affiliation = ""; row.ballot_designating_entity = "PSRM"; }
+}
+
+const extraResults = [];
+function addResult(id, electionId, name, affiliation, designator, votes, rank, outcome, seats, sourceId, notes = "") {
+  const total = resultTotals[electionId];
+  extraResults.push({ result_id: id, election_id: electionId, geographic_unit_type: "national", geographic_unit_code: electionId.includes("ro-") ? "ROU" : "MDA", geographic_unit_name: electionId.includes("ro-") ? "Romania" : "Moldova", contest_name: electionId.includes("parl") ? "Parliamentary election" : "Presidential election", candidate_or_option: name, party_or_affiliation: affiliation, ballot_designating_entity: designator, votes, valid_vote_share: total && votes ? votes / total : votes === 0 ? 0 : "", rank, outcome, seats, result_status: electionId === "elec-ro-pres-2024-r1" ? "final_tally_validated_then_process_void" : electionId === "elec-ro-pres-2025-r1" ? "CCR_confirmed_and_validated" : "CEC_final_and_Constitutional_Court_confirmed", coverage_status: "complete_national_contest", official_source_id: sourceId, as_of_date: "2026-08-12", notes });
+}
+[
+  ["simion", "George-Nicolae Simion", "AUR", 1281325], ["ciuca", "Nicolae-Ionel Ciucă", "PNL", 811952], ["geoana", "Mircea-Dan Geoană", "independent", 583898], ["kelemen", "Hunor Kelemen", "UDMR", 416353], ["diaconescu", "Cristian Diaconescu", "independent", 286842], ["terhes", "Cristian-Vasile Terheș", "PNCR", 95782], ["birchall", "Ana Birchall", "independent", 42853], ["orban", "Ludovic Orban", "Forța Dreptei", 20089], ["popescu", "Sebastian-Constantin Popescu", "Partidul Noua Românie", 14683], ["bertalan", "Alexandra-Beatrice Bertalan-Păcuraru", "Alternativa pentru Demnitate Națională", 14502], ["predoiu", "Silviu Predoiu", "Partidul Liga Acțiunii Naționale", 11246]
+].forEach(([slug, name, party, votes], index) => addResult(`result-ro24-${slug}`, "elec-ro-pres-2024-r1", name, party, "", votes, index + 4, "not_advanced_before_annulment", "", "off-ro-2024-ccr-h31", "Final tally first validated by H31, then the process was voided by H32."));
+[
+  ["ponta", "Victor-Viorel Ponta", "independent", 1230164], ["lasconi", "Elena-Valerica Lasconi", "USR", 252721], ["sandru", "Marcela-Lavinia Șandru", "PUSL", 60682], ["funeriu", "Petru-Daniel Funeriu", "independent", 49604], ["terhes", "Cristian-Vasile Terheș", "PNCR", 36445], ["popescu", "Sebastian-Constantin Popescu", "Partidul Noua Românie", 25994], ["banu", "John-Ion Banu-Muscel", "independent", 22020], ["predoiu", "Silviu Predoiu", "Partidul Liga Acțiunii Naționale", 17186]
+].forEach(([slug, name, party, votes], index) => addResult(`result-ro25r1-${slug}`, "elec-ro-pres-2025-r1", name, party, "", votes, index + 4, "not_advanced", "", "off-ro-2025-ccr-h39"));
+[
+  ["vlah", "Irina Vlah", "independent", "", 83193], ["furtuna", "Victoria Furtună", "independent", "", 68778], ["tarlev", "Vasile Tarlev", "", "Partidul pentru Viitorul Moldovei", 49316], ["chicu", "Ion Chicu", "", "Partidul Dezvoltării și Consolidării Moldovei", 31797], ["ticu", "Octavian Țîcu", "", "Blocul Electoral Împreună", 14326], ["nastase", "Andrei Năstase", "independent", "", 9946], ["morari", "Natalia Morari", "independent", "", 9444], ["ulianovschi", "Tudor Ulianovschi", "independent", "", 7995]
+].forEach(([slug, name, party, designator, votes], index) => addResult(`result-md24r1-${slug}`, "elec-md-pres-2024-r1", name, party, designator, votes, index + 4, "not_advanced", "", "off-md-2024-pres-cc-h25"));
+
+const mdSeats = {
+  "result-mdparl-pas": ["Partidul Acțiune și Solidaritate (PAS)", 55, "gained_seats"],
+  "result-mdparl-patriotic-bloc": ["Blocul Electoral Patriotic al Socialiștilor, Comuniștilor, Inima și Viitorul Moldovei", 26, "gained_seats"],
+  "result-mdparl-alternative-bloc": ["Blocul Electoral Alternativa", 8, "gained_seats"],
+  "result-mdparl-our-party": ["Partidul Nostru", 6, "gained_seats"],
+  "result-mdparl-democracy-at-home": ["Partidul Democrația Acasă", 6, "gained_seats"]
+};
+for (const row of seed.official_results) {
+  if (mdSeats[row.result_id]) {
+    [row.candidate_or_option, row.seats, row.outcome] = mdSeats[row.result_id];
+    row.official_source_id = "off-md-2025-cec-h4151";
+  }
+}
+[
+  ["psde", "Partidul Social Democrat European", 15060, 6], ["andrei-nastase", "Andrei Năstase", 13420, 7], ["cub", "Coaliția pentru Unitate și Bunăstare", 13314, 8], ["respect", "Respect Moldova", 10144, 9], ["loc", "Liga Orașelor și Comunelor", 6120, 10], ["stamate", "Olesea Stamate", 5257, 11], ["impreuna", "Blocul Electoral Împreună", 5030, 12], ["pnm", "Partidul Național Moldovenesc", 4813, 13], ["alde", "ALDE", 3576, 14], ["moldovenii", "Alianța Moldovenii", 3509, 15], ["sanduta", "Victoria Sanduța", 2862, 16], ["ucs", "Uniunea Creștin-Socială", 1837, 17], ["aur", "AUR", 1604, 18], ["cretu", "Tatiana Crețu", 1598, 19], ["liberal", "Partidul Liberal", 1591, 20], ["noi", "Noua Opțiune Istorică", 1412, 21], ["bun", "Blocul Unirea Națiunii", 797, 22]
+].forEach(([slug, name, votes, rank]) => addResult(`result-mdparl-${slug}`, "elec-md-parl-2025", name, name.includes("Andrei") || name.includes("Olesea") || name.includes("Victoria") || name.includes("Tatiana") ? "independent" : "", "", votes, rank, "no_seats", 0, "off-md-2025-cec-h4151"));
+addResult("result-mdparl-moldova-mare", "elec-md-parl-2025", "Partidul Moldova Mare", "", "", 0, "", "excluded_ballots_invalidated", 0, "off-md-2025-cec-h4151", "Registered competitor; zero valid votes after ballots were invalidated. One Tokyo vote was reclassified invalid according to the official record.");
+seed.official_results.push(...extraResults);
+
+seed.claims = seed.claims.map((claim) => {
+  const confidence = Number(claim.confidence);
+  let claimStatus = "unresolved";
+  let evidenceStrength = "none";
+  if (claim.evidence_label === "established_evidence") { claimStatus = "supported"; evidenceStrength = confidence >= 0.9 ? "high" : "moderate"; }
+  if (claim.evidence_label === "established_as_campaign_report") { claimStatus = "supported_as_attributed_measurement"; evidenceStrength = "moderate"; }
+  if (claim.evidence_label === "strong_inference") { claimStatus = "partly_supported"; evidenceStrength = confidence >= 0.8 ? "moderate" : "low"; }
+  return { ...claim, coder_confidence_in_label: claim.confidence, claim_status: claimStatus, evidence_strength: evidenceStrength };
+});
+
+seed.sources = seed.sources.map((source) => {
+  const interestedTypes = /campaign|platform|provider|party/.test(source.source_type);
+  const reproducibleTypes = /model_evaluation|peer_reviewed|dataset|methodology/.test(source.source_type);
+  return {
+    ...source,
+    source_independence: source.source_independence || (interestedTypes ? "interested_or_mixed" : source.primary_secondary === "primary" ? "independent_or_official" : "independent_secondary"),
+    method_transparency: source.method_transparency || (reproducibleTypes ? "sufficiently_described_or_reproducible" : /official|legal|regulatory/.test(source.source_type) ? "not_applicable_official_record" : "limited_to_published_account"),
+    access_status: source.access_status || "public_url_at_cutoff",
+    archive_url: source.archive_url || "",
+    content_hash: source.content_hash || ""
+  };
+});
+
+seed.case_actors = rowsFromArrays(extensions.case_actors, schemas.case_actors);
+seed.technology_uses = rowsFromArrays(extensions.technology_uses, schemas.technology_uses);
+seed.content_items = rowsFromArrays(extensions.content_items, schemas.content_items);
+seed.pathways = rowsFromArrays(extensions.agency_transfer_assessments, schemas.pathways);
+seed.model_evaluations = rowsFromArrays(extensions.model_evaluations, schemas.model_evaluations);
+
+const pathwayByCase = new Map(seed.pathways.map((row) => [row.case_id, row.pathway_id]));
+const caseById = new Map(seed.cases.map((row) => [row.case_id, row]));
+const metricFamily = (name) => /view|impression|reach|audience/.test(name) ? "exposure_or_distribution" : /account|page|post|video|question|call|message|asset|content/.test(name) ? "production_or_engagement" : /fine|charge|removal|deadline|response/.test(name) ? "institutional_response" : "descriptive_context";
+seed.observations = extensions.quantitative_observations.map((values) => {
+  const [observation_id, case_id, claim_id, metric_name, value_best, value_operator, platform, measurement_window, denominator, unique_entity_status, causalRaw, measurement_method, source_id, limitations] = values;
+  const exact = ["exact", "exact_report", "exact_campaign_report"].includes(value_operator);
+  const atLeast = String(value_operator).startsWith("at_least");
+  return { observation_id, case_id, pathway_id: pathwayByCase.get(case_id) || "", claim_id, metric_family: metricFamily(metric_name), metric_name, value_low: exact || atLeast ? value_best : "", value_best, value_high: exact ? value_best : "", value_operator, unit: metric_name, denominator, unique_entity_status, platform, geographic_scope: caseById.get(case_id)?.country || "", measurement_window, measurement_method, causal_status: causalRaw === "yes" ? "causal_estimate_limited" : "descriptive_only", source_id, as_of_date: caseById.get(case_id)?.last_verified || "2026-08-12", limitations };
+});
+
+const sourceById = new Map(seed.sources.map((row) => [row.source_id, row]));
+seed.claim_evidence = [];
+for (const claim of seed.claims) {
+  const evidenceScope = claim.claim_type === "reach" ? "measurement" : claim.claim_type === "response" ? "institutional_action" : claim.claim_type === "agency_transfer" ? "researcher_inference" : "underlying_fact";
+  for (const [relation, ids] of [["supports", claim.source_ids], ["counterevidence", claim.counter_source_ids]]) {
+    for (const sourceId of String(ids || "").split("|").filter(Boolean)) {
+      const source = sourceById.get(sourceId);
+      const directness = source?.primary_secondary === "primary" ? (/official|legal|regulatory|court/.test(source.source_type) ? "official_record_or_allegation" : "firsthand_artifact_or_measurement") : "independent_secondary_reporting";
+      seed.claim_evidence.push({ claim_evidence_id: `ce-${claim.claim_id}-${sourceId}-${relation}`, claim_id: claim.claim_id, source_id: sourceId, relation, evidence_scope: evidenceScope, directness, locator: "", extracted_at: claim.verified_at });
+    }
+  }
+}
+
+seed.analytic_record_claims = [];
+for (const [recordType, table, idField] of [
+  ["case_actor", seed.case_actors, "case_actor_id"],
+  ["technology_use", seed.technology_uses, "tech_use_id"],
+  ["content_item", seed.content_items, "content_item_id"],
+  ["pathway", seed.pathways, "pathway_id"],
+  ["event", seed.events, "event_id"]
+]) {
+  for (const record of table) {
+    for (const claimId of String(record.source_claim_ids || record.claim_ids || "").split("|").filter(Boolean)) {
+      seed.analytic_record_claims.push({ record_claim_id: `record-claim-${recordType}-${record[idField]}-${claimId}`, record_type: recordType, record_id: record[idField], case_id: record.case_id, claim_id: claimId, relation: "supports_coding" });
+    }
+  }
+}
+
+seed.case_elections = [];
+seed.election_sources = [];
+for (const election of seed.official_elections) {
+  for (const caseId of String(election.linked_case_ids || "").split("|").filter(Boolean)) {
+    seed.case_elections.push({ case_election_id: `case-election-${caseId}-${election.election_id}`, case_id: caseId, election_id: election.election_id, relation: election.election_status === "scheduled" || election.election_status === "conditional" ? "future_or_campaign_context" : "primary_or_institutional_context" });
+  }
+  for (const sourceId of String(election.official_source_ids || "").split("|").filter(Boolean)) {
+    seed.election_sources.push({ election_source_id: `election-source-${election.election_id}-${sourceId}`, election_id: election.election_id, official_source_id: sourceId, source_role: "supports_election_context_or_status" });
+  }
+}
+
+function evidenceForCase(caseId) {
+  const strengths = seed.claims.filter((claim) => claim.case_id === caseId).map((claim) => claim.evidence_strength);
+  return strengths.includes("high") ? "high_for_occurrence_mixed_for_effect" : strengths.includes("moderate") ? "moderate" : "low_or_unresolved";
+}
+function reachForCase(caseId) {
+  const rows = seed.observations.filter((row) => row.case_id === caseId).slice(0, 2);
+  if (!rows.length) return "No typed population-reach estimate";
+  return rows.map((row) => `${Number(row.value_best).toLocaleString("en-US")} ${row.unit}; ${row.measurement_method}; ${row.unique_entity_status}; ${row.measurement_window}`).join(" | ");
+}
+seed.research_view = seed.pathways.map((pathway) => {
+  const item = caseById.get(pathway.case_id);
+  const tech = seed.technology_uses.filter((row) => row.case_id === pathway.case_id).map((row) => [row.provider, row.product_or_model].filter(Boolean).join(": ")).join(" | ") || "not identified or not applicable";
+  return { pathway_id: pathway.pathway_id, case_id: item.case_id, case_title: item.title, country: item.country, election_date: item.election_date_start, record_type: item.record_type, case_status: item.case_status, manipulation_assessment: item.manipulation_assessment, generative_ai_status: item.generative_ai_status, ai_role: item.ai_role, system_or_model: tech, controller: item.actor_controlling_system, influence_vector: item.influence_vector, target: item.target_population, affected_agency: pathway.affected_agency, agency_transfer_status: pathway.agency_transfer_status, power_recipient: pathway.power_recipient, reach_summary: reachForCase(item.case_id), behavioural_effect: item.behavioural_effect_status, electoral_effect: item.electoral_effect_status, evidence_strength: evidenceForCase(item.case_id), main_uncertainty: item.open_questions, last_verified: item.last_verified };
+});
+
+const sourceCountByCase = new Map();
+for (const link of seed.case_sources) sourceCountByCase.set(link.case_id, (sourceCountByCase.get(link.case_id) || 0) + 1);
+seed.case_catalog = [
+  ...seed.cases.map((row) => ({ catalog_id: row.case_id, record_layer: "claim_coded_core", record_type: row.record_type, title: row.title, country: row.country, region: row.region, election_name: row.election_name, election_date: row.election_date_start, case_status: row.case_status, manipulation_assessment: row.manipulation_assessment, ai_role: row.ai_role, generative_ai_status: row.generative_ai_status, evidence_maturity: evidenceForCase(row.case_id), incident_count_eligible: row.record_type === "preparedness_file" ? "false" : "true", research_status: "included_claim_coded", source_count_or_links: sourceCountByCase.get(row.case_id) || 0, main_caveat: row.counterevidence, last_checked: row.last_verified })),
+  ...seed.candidates.map((row) => ({ catalog_id: row.candidate_id, record_layer: "screening_register", record_type: "candidate_lead", title: row.title, country: row.country, region: row.region, election_name: row.election_name, election_date: row.election_date, case_status: row.research_status, manipulation_assessment: "not_yet_claim_coded", ai_role: row.ai_role, generative_ai_status: row.generative_ai_status, evidence_maturity: row.occurrence_status, incident_count_eligible: "false", research_status: row.research_status, source_count_or_links: String(row.source_urls || "").split("|").filter(Boolean).length, main_caveat: row.main_caveat, last_checked: row.last_checked })),
+  ...seed.model_evaluations.map((row) => ({ catalog_id: row.evaluation_id, record_layer: "empirical_model_study", record_type: "model_evaluation_or_experiment", title: row.title, country: row.country, region: regionForCountry(row.country), election_name: row.election_or_context, election_date: row.evaluation_window, case_status: "completed_study", manipulation_assessment: "not_an_incident", ai_role: "tested_system_capability", generative_ai_status: "confirmed_tested_system", evidence_maturity: "study_design_specific", incident_count_eligible: "false", research_status: "included_empirical_study", source_count_or_links: 1, main_caveat: row.causal_scope, last_checked: "2026-08-12" }))
+];
+
+const frameNotes = {
+  Europe: "Strongest current core coverage; still purposive and concentrated in Romania/Moldova.",
+  "North America": "One adjudicated 2024 robocall, two 2026 campaign records, and several model audits; no prevalence frame.",
+  "South America": "Brazil core is mainly preparedness/current use; completed Colombia/Ecuador leads remain to be disaggregated.",
+  Asia: "Screening leads exist but no claim-coded core case yet.",
+  Africa: "Screening leads exist but no claim-coded core case yet.",
+  Oceania: "One knowledge-poisoning lead; no claim-coded core case yet.",
+  "Cross-national": "Empirical studies span jurisdictions; not incident counts."
+};
+const regions = Object.keys(frameNotes);
+seed.sampling_frame = regions.map((region) => {
+  const included = seed.cases.filter((row) => canonicalRegion(row.region) === region).length;
+  const candidates = seed.candidates.filter((row) => canonicalRegion(row.region) === region).length;
+  return { frame_id: `frame-${region.toLowerCase().replaceAll(/[^a-z]+/g, "-")}`, region, selection_basis: "purposive anchor cases plus structured comparative screening; not a census", search_status: included || candidates ? "partial" : "not_started", search_languages: region === "Europe" ? "en|ro|pt|selected_local_sources" : "primarily_en_with_selected_local_sources", source_channels: "official election bodies|courts|platform reports|peer-reviewed studies|fact-checkers|investigative reporting", included_case_count: included, candidate_count: candidates, negative_search_recorded: region === "South America" ? "true" : "false", known_gap: frameNotes[region], last_searched: "2026-08-12" };
+});
+seed.coverage_summary = regions.map((region) => ({ region, included_case_count: seed.cases.filter((row) => canonicalRegion(row.region) === region).length, candidate_count: seed.candidates.filter((row) => canonicalRegion(row.region) === region).length, model_evaluation_count: seed.model_evaluations.filter((row) => regionForCountry(row.country) === region).length, coverage_note: frameNotes[region] }));
+
 function csvCell(value) {
   if (value === null || value === undefined) return "";
   const s = Array.isArray(value) ? value.join("|") : String(value);
@@ -132,6 +558,17 @@ assertUnique(seed.official_elections, "election_id", "official_elections");
 assertUnique(seed.official_turnout, "turnout_id", "official_turnout");
 assertUnique(seed.official_results, "result_id", "official_results");
 assertUnique(seed.official_data_sources, "official_source_id", "official_data_sources");
+assertUnique(seed.official_election_metrics, "metric_id", "official_election_metrics");
+assertUnique(seed.case_actors, "case_actor_id", "case_actors");
+assertUnique(seed.technology_uses, "tech_use_id", "technology_uses");
+assertUnique(seed.content_items, "content_item_id", "content_items");
+assertUnique(seed.pathways, "pathway_id", "pathways");
+assertUnique(seed.observations, "observation_id", "observations");
+assertUnique(seed.model_evaluations, "evaluation_id", "model_evaluations");
+assertUnique(seed.claim_evidence, "claim_evidence_id", "claim_evidence");
+assertUnique(seed.analytic_record_claims, "record_claim_id", "analytic_record_claims");
+assertUnique(seed.case_elections, "case_election_id", "case_elections");
+assertUnique(seed.election_sources, "election_source_id", "election_sources");
 
 for (const claim of seed.claims) {
   if (!caseIds.has(claim.case_id)) throw new Error("Unknown case in claim " + claim.claim_id);
@@ -182,6 +619,25 @@ for (const row of seed.official_results) {
   if (!electionIds.has(row.election_id)) throw new Error("Unknown election in official_results " + row.result_id);
   if (!officialSourceIds.has(row.official_source_id)) throw new Error("Unknown official source in official_results " + row.result_id);
 }
+for (const row of seed.official_election_metrics) {
+  if (!electionIds.has(row.election_id)) throw new Error("Unknown election in official_election_metrics " + row.metric_id);
+  if (!officialSourceIds.has(row.official_source_id)) throw new Error("Unknown official source in official_election_metrics " + row.metric_id);
+}
+for (const row of [...seed.case_actors, ...seed.technology_uses, ...seed.content_items, ...seed.pathways, ...seed.observations]) {
+  if (!caseIds.has(row.case_id)) throw new Error("Unknown case in analytic record " + (row.case_actor_id || row.tech_use_id || row.content_item_id || row.pathway_id || row.observation_id));
+}
+for (const row of seed.claim_evidence) {
+  if (!claimIds.has(row.claim_id) || !sourceIds.has(row.source_id)) throw new Error("Unknown claim/source in " + row.claim_evidence_id);
+}
+for (const row of seed.analytic_record_claims) {
+  if (!caseIds.has(row.case_id) || !claimIds.has(row.claim_id)) throw new Error("Unknown case/claim in " + row.record_claim_id);
+}
+for (const row of seed.case_elections) {
+  if (!caseIds.has(row.case_id) || !electionIds.has(row.election_id)) throw new Error("Unknown case/election in " + row.case_election_id);
+}
+for (const row of seed.election_sources) {
+  if (!electionIds.has(row.election_id) || !officialSourceIds.has(row.official_source_id)) throw new Error("Unknown election/source in " + row.election_source_id);
+}
 
 fs.mkdirSync(outDir, { recursive: true });
 const fileHashes = {};
@@ -196,6 +652,71 @@ const schemaText = JSON.stringify(schemas, null, 2) + "\n";
 fs.writeFileSync(path.join(outDir, "schema.json"), schemaText);
 fileHashes["schema.json"] = sha256(schemaText);
 
+const primaryKeys = {
+  cases: "case_id", claims: "claim_id", sources: "source_id", events: "event_id",
+  watchlist: "watch_id", candidates: "candidate_id", official_elections: "election_id",
+  official_turnout: "turnout_id", official_results: "result_id",
+  official_data_sources: "official_source_id", official_election_metrics: "metric_id",
+  case_catalog: "catalog_id", case_actors: "case_actor_id", technology_uses: "tech_use_id",
+  content_items: "content_item_id", pathways: "pathway_id", observations: "observation_id",
+  model_evaluations: "evaluation_id", claim_evidence: "claim_evidence_id",
+  analytic_record_claims: "record_claim_id", case_elections: "case_election_id",
+  election_sources: "election_source_id", sampling_frame: "frame_id"
+};
+const foreignKeys = {
+  claims: [["case_id", "cases", "case_id"]],
+  events: [["case_id", "cases", "case_id"]],
+  case_sources: [["case_id", "cases", "case_id"], ["source_id", "sources", "source_id"]],
+  watchlist: [["case_id", "cases", "case_id"]],
+  official_turnout: [["election_id", "official_elections", "election_id"], ["official_source_id", "official_data_sources", "official_source_id"]],
+  official_results: [["election_id", "official_elections", "election_id"], ["official_source_id", "official_data_sources", "official_source_id"]],
+  official_election_metrics: [["election_id", "official_elections", "election_id"], ["official_source_id", "official_data_sources", "official_source_id"]],
+  research_view: [["case_id", "cases", "case_id"], ["pathway_id", "pathways", "pathway_id"]],
+  case_actors: [["case_id", "cases", "case_id"]],
+  technology_uses: [["case_id", "cases", "case_id"]],
+  content_items: [["case_id", "cases", "case_id"]],
+  pathways: [["case_id", "cases", "case_id"]],
+  observations: [["case_id", "cases", "case_id"], ["pathway_id", "pathways", "pathway_id"], ["claim_id", "claims", "claim_id"], ["source_id", "sources", "source_id"]],
+  claim_evidence: [["claim_id", "claims", "claim_id"], ["source_id", "sources", "source_id"]],
+  analytic_record_claims: [["case_id", "cases", "case_id"], ["claim_id", "claims", "claim_id"]],
+  case_elections: [["case_id", "cases", "case_id"], ["election_id", "official_elections", "election_id"]],
+  election_sources: [["election_id", "official_elections", "election_id"], ["official_source_id", "official_data_sources", "official_source_id"]]
+};
+const integerFields = new Set(["votes", "rank", "seats", "registered_voters", "ballots_cast", "turnout_numerator", "valid_votes", "invalid_votes", "reporting_units_total", "reporting_units_counted", "sample_size", "included_case_count", "candidate_count", "model_evaluation_count", "source_count_or_links", "content_bytes"]);
+const numberFields = new Set(["confidence", "coder_confidence_in_label", "overall_confidence", "turnout_rate", "authority_reported_turnout_rate", "valid_vote_share", "authority_reported_rate", "computed_rate", "value", "value_low", "value_best", "value_high"]);
+const dateFields = new Set(["election_date_start", "election_date_end", "as_of_date", "last_verified", "verified_at", "retrieved_at", "publication_date", "event_date", "election_date", "last_checked", "last_searched", "snapshot_cutoff"]);
+const booleanFields = new Set(["anchor_case", "incident_count_eligible", "negative_search_recorded"]);
+function fieldDescriptor(name) {
+  if (booleanFields.has(name)) return { name, type: "boolean", trueValues: ["true"], falseValues: ["false"] };
+  if (integerFields.has(name)) return { name, type: "integer" };
+  if (numberFields.has(name)) return { name, type: "number" };
+  if (dateFields.has(name)) return { name, type: "date" };
+  return { name, type: "string" };
+}
+const dataPackage = {
+  profile: "tabular-data-package",
+  name: "agency-transfer-election-cases",
+  title: "AI, Elections and Agency Transfer Evidence Index",
+  version: "0.3.0",
+  description: "Purposive, claim-level research corpus with normalized pathways, observations, empirical model studies, screening records and official electoral context. Not a global prevalence sample.",
+  licenses: [{ name: "CC-BY-4.0", path: "https://creativecommons.org/licenses/by/4.0/" }],
+  resources: Object.entries(schemas).map(([table, columns]) => ({
+    name: table,
+    path: `${table}.csv`,
+    profile: "tabular-data-resource",
+    format: "csv",
+    mediatype: "text/csv",
+    schema: {
+      fields: columns.map(fieldDescriptor),
+      ...(primaryKeys[table] ? { primaryKey: primaryKeys[table] } : {}),
+      ...(foreignKeys[table]?.length ? { foreignKeys: foreignKeys[table].map(([field, resource, targetField]) => ({ fields: field, reference: { resource, fields: targetField } })) } : {})
+    }
+  }))
+};
+const dataPackageText = JSON.stringify(dataPackage, null, 2) + "\n";
+fs.writeFileSync(path.join(outDir, "datapackage.json"), dataPackageText);
+fileHashes["datapackage.json"] = sha256(dataPackageText);
+
 const counts = Object.fromEntries(Object.keys(schemas).map((table) => [table, seed[table].length]));
 const stats = {
   ...counts,
@@ -204,7 +725,8 @@ const stats = {
       "research/seed.json": sha256(fs.readFileSync(seedPath)),
       "research/candidates.json": sha256(fs.readFileSync(candidatesPath)),
       "research/europe_candidates.json": sha256(fs.readFileSync(europeCandidatesPath)),
-      "research/official_electoral_data.json": sha256(fs.readFileSync(officialElectoralDataPath))
+      "research/official_electoral_data.json": sha256(fs.readFileSync(officialElectoralDataPath)),
+      "research/v0.3_extensions.json": sha256(fs.readFileSync(extensionsPath))
     },
     file_sha256: fileHashes
   }

scripts/build-parquet.mjs

@@ -0,0 +1,75 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+const require = createRequire(import.meta.url);
+const parquet = require("parquetjs-lite");
+const here = path.dirname(fileURLToPath(import.meta.url));
+const root = path.resolve(here, "..");
+const dataDir = path.join(root, "data");
+const outDir = path.join(root, "parquet");
+await fs.mkdir(outDir, { recursive: true });
+
+function parseCsv(text) {
+  const records = [];
+  let record = [];
+  let field = "";
+  let quoted = false;
+  for (let i = 0; i < text.length; i += 1) {
+    const char = text[i];
+    if (quoted) {
+      if (char === '"' && text[i + 1] === '"') { field += '"'; i += 1; }
+      else if (char === '"') quoted = false;
+      else field += char;
+    } else if (char === '"') quoted = true;
+    else if (char === ",") { record.push(field); field = ""; }
+    else if (char === "\n") { record.push(field.replace(/\r$/, "")); records.push(record); record = []; field = ""; }
+    else field += char;
+  }
+  if (field || record.length) { record.push(field.replace(/\r$/, "")); records.push(record); }
+  const headers = records.shift() || [];
+  return records.filter((row) => row.some((value) => value !== "")).map((values) =>
+    Object.fromEntries(headers.map((header, index) => [header, values[index] ?? ""]))
+  );
+}
+
+function parquetType(field) {
+  if (field.type === "integer") return "INT64";
+  if (field.type === "number") return "DOUBLE";
+  if (field.type === "boolean") return "BOOLEAN";
+  return "UTF8";
+}
+
+function convert(value, field) {
+  if (value === "" || value === null || value === undefined) return undefined;
+  if (field.type === "integer") return Number.parseInt(value, 10);
+  if (field.type === "number") return Number(value);
+  if (field.type === "boolean") return String(value).toLowerCase() === "true";
+  return String(value);
+}
+
+const pkg = JSON.parse(await fs.readFile(path.join(dataDir, "datapackage.json"), "utf8"));
+const manifest = [];
+for (const resource of pkg.resources) {
+  const rows = parseCsv(await fs.readFile(path.join(dataDir, resource.path), "utf8"));
+  const fields = resource.schema.fields;
+  const parquetSchema = new parquet.ParquetSchema(Object.fromEntries(fields.map((field) => [field.name, { type: parquetType(field), optional: true }])));
+  const output = path.join(outDir, `${resource.name}.parquet`);
+  const writer = await parquet.ParquetWriter.openFile(parquetSchema, output);
+  for (const sourceRow of rows) {
+    const row = {};
+    for (const field of fields) {
+      const value = convert(sourceRow[field.name], field);
+      if (value !== undefined && !Number.isNaN(value)) row[field.name] = value;
+    }
+    await writer.appendRow(row);
+  }
+  await writer.close();
+  const stat = await fs.stat(output);
+  const digest = createHash("sha256").update(await fs.readFile(output)).digest("hex");
+  manifest.push({ table: resource.name, rows: rows.length, file: `parquet/${resource.name}.parquet`, bytes: stat.size, sha256: digest });
+}
+await fs.writeFile(path.join(outDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);
+process.stdout.write(`${JSON.stringify({ tables: manifest.length, rows: manifest.reduce((sum, item) => sum + item.rows, 0) })}\n`);

scripts/build-workbook-v03.mjs

@@ -0,0 +1,314 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { SpreadsheetFile, Workbook } from "@oai/artifact-tool";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const root = process.env.DATASET_ROOT ? path.resolve(process.env.DATASET_ROOT) : path.resolve(here, "..");
+const dataDir = path.join(root, "data");
+const outputDir = process.argv[2] || path.join(root, "outputs", "v0.3.0-workbook");
+const previewDir = path.join(outputDir, "previews");
+await fs.mkdir(previewDir, { recursive: true });
+
+function parseCsv(text) {
+  const records = [];
+  let record = [];
+  let field = "";
+  let quoted = false;
+  for (let i = 0; i < text.length; i += 1) {
+    const char = text[i];
+    if (quoted) {
+      if (char === '"' && text[i + 1] === '"') { field += '"'; i += 1; }
+      else if (char === '"') quoted = false;
+      else field += char;
+    } else if (char === '"') quoted = true;
+    else if (char === ",") { record.push(field); field = ""; }
+    else if (char === "\n") {
+      record.push(field.replace(/\r$/, ""));
+      records.push(record);
+      record = [];
+      field = "";
+    } else field += char;
+  }
+  if (field || record.length) { record.push(field.replace(/\r$/, "")); records.push(record); }
+  const headers = records.shift() || [];
+  return records.filter((row) => row.some((value) => value !== "")).map((values) =>
+    Object.fromEntries(headers.map((header, index) => [header, values[index] ?? ""]))
+  );
+}
+
+const schema = JSON.parse(await fs.readFile(path.join(dataDir, "schema.json"), "utf8"));
+const stats = JSON.parse(await fs.readFile(path.join(dataDir, "stats.json"), "utf8"));
+const audit = JSON.parse(await fs.readFile(path.join(dataDir, "audit-v03.json"), "utf8"));
+const data = {};
+for (const table of Object.keys(schema)) {
+  data[table] = parseCsv(await fs.readFile(path.join(dataDir, `${table}.csv`), "utf8"));
+}
+
+const wb = Workbook.create();
+const colors = {
+  ink: "#111827", charcoal: "#263238", slate: "#4B5563", blue: "#24506A",
+  paleBlue: "#EAF2F7", gray: "#E5E7EB", light: "#F8FAFC", white: "#FFFFFF",
+  red: "#B42318", paleRed: "#FDECEC", green: "#16794C", paleGreen: "#EAF7F0",
+  amber: "#946200", paleAmber: "#FFF6D8"
+};
+
+function excelColumn(index) {
+  let n = index + 1;
+  let out = "";
+  while (n > 0) { n -= 1; out = String.fromCharCode(65 + (n % 26)) + out; n = Math.floor(n / 26); }
+  return out;
+}
+
+const numericFields = new Set([
+  "confidence", "coder_confidence_in_label", "overall_confidence", "reach_estimate",
+  "registered_voters", "ballots_cast", "turnout_numerator", "valid_votes", "invalid_votes",
+  "turnout_rate", "authority_reported_turnout_rate", "reporting_units_total", "reporting_units_counted",
+  "votes", "valid_vote_share", "rank", "seats", "value", "authority_reported_rate", "computed_rate",
+  "value_low", "value_best", "value_high", "sample_size", "included_case_count", "candidate_count",
+  "model_evaluation_count", "source_count_or_links", "content_bytes"
+]);
+const percentFields = new Set(["turnout_rate", "authority_reported_turnout_rate", "valid_vote_share", "authority_reported_rate", "computed_rate"]);
+const integerFields = new Set(["registered_voters", "ballots_cast", "turnout_numerator", "valid_votes", "invalid_votes", "reporting_units_total", "reporting_units_counted", "votes", "rank", "seats", "sample_size", "included_case_count", "candidate_count", "model_evaluation_count", "source_count_or_links", "content_bytes"]);
+
+function valueForCell(column, value) {
+  if (value === "" || value === null || value === undefined) return "";
+  if (/^(true|false)$/i.test(String(value))) return String(value).toLowerCase() === "true";
+  if ((column.endsWith("_date") || column.endsWith("_at") || ["last_verified", "event_date", "last_checked", "last_searched", "as_of_date", "snapshot_cutoff"].includes(column)) && /^\d{4}-\d{2}-\d{2}$/.test(String(value))) {
+    return new Date(`${value}T00:00:00Z`);
+  }
+  if (numericFields.has(column) && Number.isFinite(Number(value))) return Number(value);
+  return value;
+}
+
+function safeTableName(name) {
+  return `T${name.replaceAll(/[^A-Za-z0-9]/g, "").slice(0, 44)}`;
+}
+
+function addDataSheet(sheetName, rows, columns, options = {}) {
+  const sheet = wb.worksheets.add(sheetName);
+  sheet.showGridLines = false;
+  const matrix = [columns, ...rows.map((row) => columns.map((column) => valueForCell(column, row[column] ?? "")))];
+  const lastCol = excelColumn(columns.length - 1);
+  const lastRow = Math.max(matrix.length, 2);
+  sheet.getRange(`A1:${lastCol}${matrix.length}`).values = matrix;
+  sheet.getRange(`A1:${lastCol}1`).format = {
+    fill: options.headerFill || colors.charcoal,
+    font: { bold: true, color: colors.white, size: 10 },
+    wrapText: true,
+    verticalAlignment: "center",
+    borders: { preset: "all", style: "thin", color: colors.white }
+  };
+  sheet.getRange(`A1:${lastCol}1`).format.rowHeightPx = 38;
+  sheet.getRange(`A2:${lastCol}${lastRow}`).format = {
+    font: { color: colors.ink, size: 9 },
+    wrapText: true,
+    verticalAlignment: "top",
+    borders: { preset: "all", style: "thin", color: "#D9DEE3" }
+  };
+  sheet.getRange(`A2:${lastCol}${lastRow}`).format.rowHeightPx = options.rowHeight || 58;
+  sheet.freezePanes.freezeRows(1);
+  sheet.freezePanes.freezeColumns(Math.min(options.freezeColumns ?? 2, columns.length));
+  for (let i = 0; i < columns.length; i += 1) {
+    const column = columns[i];
+    const letter = excelColumn(i);
+    const width = options.widths?.[column] || (
+      /summary|claim_text|notes|counterevidence|open_questions|description|path|mechanism|outcome|scope|uncertainty|limitation|caveat|headline|selection_basis|coverage_note/.test(column) ? 360 :
+      /url/.test(column) ? 300 :
+      /title|name|controller|target|actor/.test(column) ? 250 :
+      /id$/.test(column) ? 210 : 135
+    );
+    sheet.getRange(`${letter}1:${letter}${lastRow}`).format.columnWidthPx = width;
+    if ((column.endsWith("_date") || column.endsWith("_at") || ["last_verified", "last_checked", "last_searched", "as_of_date", "snapshot_cutoff"].includes(column)) && lastRow >= 2) {
+      sheet.getRange(`${letter}2:${letter}${lastRow}`).format.numberFormat = "yyyy-mm-dd";
+    } else if (percentFields.has(column) && lastRow >= 2) {
+      sheet.getRange(`${letter}2:${letter}${lastRow}`).format.numberFormat = "0.00%";
+    } else if (integerFields.has(column) && lastRow >= 2) {
+      sheet.getRange(`${letter}2:${letter}${lastRow}`).format.numberFormat = "#,##0";
+    } else if (["confidence", "coder_confidence_in_label", "overall_confidence"].includes(column) && lastRow >= 2) {
+      sheet.getRange(`${letter}2:${letter}${lastRow}`).format.numberFormat = "0.00";
+    }
+  }
+  if (rows.length) {
+    const table = sheet.tables.add(`A1:${lastCol}${matrix.length}`, true, safeTableName(sheetName));
+    table.showBandedColumns = false;
+    table.showFilterButton = true;
+  }
+  return { sheet, columns, lastCol, lastRow };
+}
+
+function addSectionTitle(sheet, range, text, fill = colors.charcoal) {
+  sheet.getRange(range).merge();
+  sheet.getRange(range).values = [[text]];
+  sheet.getRange(range).format = { fill, font: { bold: true, color: colors.white, size: 11 }, verticalAlignment: "center" };
+}
+
+const overview = wb.worksheets.add("00 Overview");
+overview.showGridLines = false;
+overview.getRange("A1:H2").merge();
+overview.getRange("A1:H2").values = [["AI, Elections and Agency Transfer — Evidence Index v0.3.0"]];
+overview.getRange("A1:H2").format = { fill: colors.ink, font: { bold: true, color: colors.white, size: 18 }, verticalAlignment: "center" };
+overview.getRange("A3:H3").merge();
+overview.getRange("A3:H3").values = [["Research cutoff 2026-08-12 · Purposive evidence corpus, not a global prevalence sample · Start with 01 Research View"]];
+overview.getRange("A3:H3").format = { fill: colors.paleBlue, font: { italic: true, color: colors.blue, size: 10 }, verticalAlignment: "center" };
+
+overview.getRange("A5:B17").values = [
+  ["Release metric", "Rows"],
+  ["Claim-coded records", data.cases.length],
+  ["Incident-count eligible records", data.case_catalog.filter((row) => row.record_layer === "claim_coded_core" && row.incident_count_eligible === "true").length],
+  ["Preparedness files (excluded)", data.cases.filter((row) => row.record_type === "preparedness_file").length],
+  ["Atomic claims", data.claims.length],
+  ["Sources", data.sources.length],
+  ["Screening leads", data.candidates.length],
+  ["Empirical model studies", data.model_evaluations.length],
+  ["Typed observations", data.observations.length],
+  ["Official contests/bundles", data.official_elections.length],
+  ["Official long-form metrics", data.official_election_metrics.length],
+  ["Official result rows", data.official_results.length],
+  ["Automated audit errors", audit.summary.error_count]
+];
+overview.getRange("A5:B5").format = { fill: colors.charcoal, font: { bold: true, color: colors.white } };
+overview.getRange("A6:B17").format = { fill: colors.light, borders: { preset: "all", style: "thin", color: "#D9DEE3" } };
+
+addSectionTitle(overview, "D5:H5", "Read the layers in this order");
+overview.getRange("D6:H14").values = [[
+  "1. Research View — one concise row per agency-transfer pathway.\n\n2. Case Catalog — distinguishes claim-coded records, screening leads and empirical studies.\n\n3. Pathways + Observations — the analytic core: who controls what, what metric was actually measured, and what is not causal.\n\n4. Claims + Evidence — verify every factual sentence before using it.\n\n5. Official Metrics + Results — electoral context only; never evidence of votes caused by manipulation."
+]];
+overview.getRange("D6:H14").merge();
+overview.getRange("D6:H14").format = { fill: colors.light, borders: { preset: "all", style: "thin", color: "#D9DEE3" }, wrapText: true, verticalAlignment: "top", font: { color: colors.ink, size: 10 } };
+
+addSectionTitle(overview, "A19:H19", "What changed in v0.3.0", colors.blue);
+overview.getRange("A20:H25").values = [[
+  "The release no longer treats all rows as comparable incidents. It separates election-wide cases, observed networks, bounded incidents, campaign sets and preparedness files; preparedness is excluded from incident counts. Agency transfer is now a structured pathway rather than a narrative field. Reach is stored as typed observations with denominator, window, uniqueness and causal status. Model audits and randomized experiments are a separate empirical-study layer. Official Moldovan turnout now preserves protocol fields C and D and states the legal numerator. Romania and Moldova national result fields are complete; New Hampshire remains explicitly partial."
+]];
+overview.getRange("A20:H25").merge();
+overview.getRange("A20:H25").format = { fill: colors.paleBlue, borders: { preset: "all", style: "thin", color: colors.blue }, wrapText: true, verticalAlignment: "top", font: { color: colors.ink, size: 10 } };
+
+overview.getRange("A27:H29").merge();
+overview.getRange("A27:H29").values = [["Hard limit: this package is comprehensive within its declared evidence files, not across all elections. Six regional sampling-frame warnings remain because systematic negative searches were not recorded there. Do not estimate global prevalence or votes changed from this release."]];
+overview.getRange("A27:H29").format = { fill: colors.paleRed, font: { bold: true, color: colors.red, size: 10 }, borders: { preset: "outside", style: "medium", color: colors.red }, wrapText: true, verticalAlignment: "center" };
+overview.freezePanes.freezeRows(3);
+for (const [column, width] of [["A", 235], ["B", 110], ["C", 35], ["D", 190], ["E", 190], ["F", 190], ["G", 190], ["H", 190]]) overview.getRange(`${column}1:${column}30`).format.columnWidthPx = width;
+
+const researchColumns = ["case_id", "case_title", "country", "election_date", "record_type", "manipulation_assessment", "system_or_model", "controller", "influence_vector", "target", "affected_agency", "agency_transfer_status", "power_recipient", "reach_summary", "evidence_strength", "main_uncertainty", "last_verified"];
+const researchSheet = addDataSheet("01 Research View", data.research_view, researchColumns, { headerFill: colors.blue, freezeColumns: 3, rowHeight: 82, widths: { case_title: 310, system_or_model: 280, controller: 300, influence_vector: 330, target: 300, affected_agency: 260, power_recipient: 300, reach_summary: 400, main_uncertainty: 430 } });
+const catalogSheet = addDataSheet("02 Case Catalog", data.case_catalog, schema.case_catalog, { freezeColumns: 3, widths: { title: 330, main_caveat: 440 } });
+const coverageSheet = addDataSheet("03 Coverage", data.coverage_summary, schema.coverage_summary, { headerFill: colors.blue, widths: { coverage_note: 560 } });
+const pathwaySheet = addDataSheet("04 Pathways", data.pathways, schema.pathways, { headerFill: colors.blue, freezeColumns: 2, rowHeight: 78, widths: { control_shift_from: 300, control_shift_to: 300, mechanism: 390, harm_pathway: 390, observed_outcome: 390, reviewer_note: 420 } });
+const observationSheet = addDataSheet("05 Observations", data.observations, schema.observations, { freezeColumns: 3, widths: { limitations: 480, measurement_method: 290, denominator: 260 } });
+const modelSheet = addDataSheet("06 Model Studies", data.model_evaluations, schema.model_evaluations, { headerFill: colors.blue, freezeColumns: 2, rowHeight: 84, widths: { title: 360, systems_tested: 390, design: 430, headline_results: 520, causal_scope: 500, notes: 440 } });
+const claimSheet = addDataSheet("07 Claims", data.claims, schema.claims, { freezeColumns: 3, rowHeight: 72, widths: { claim_text: 520, notes: 390 } });
+const sourceSheet = addDataSheet("08 Sources", data.sources, schema.sources, { freezeColumns: 2, widths: { title: 390, url: 420, notes: 380 } });
+addDataSheet("09 Claim Evidence", data.claim_evidence, schema.claim_evidence, { freezeColumns: 3 });
+addDataSheet("10 Events", data.events, schema.events, { widths: { description: 480 } });
+addDataSheet("11 Actors", data.case_actors, schema.case_actors, { widths: { actor_name: 290, control_dimension: 360, notes: 420 } });
+addDataSheet("12 Technology", data.technology_uses, schema.technology_uses, { widths: { product_or_model: 330, notes: 460 } });
+addDataSheet("13 Content", data.content_items, schema.content_items, { widths: { title: 300, notes: 450 } });
+addDataSheet("14 Cases Detail", data.cases, schema.cases, { freezeColumns: 3, rowHeight: 92, widths: { summary: 430, agency_transfer_path: 510, counterevidence: 430, open_questions: 430 } });
+addDataSheet("15 Screening Leads", data.candidates, schema.candidates, { freezeColumns: 3, rowHeight: 72, widths: { title: 330, comparative_value: 430, main_caveat: 450, source_urls: 520 } });
+addDataSheet("16 Watchlist", data.watchlist, schema.watchlist, { widths: { observable_indicator: 450, defensive_data_source: 390, assessment_rule: 440, notes: 360 } });
+const electionSheet = addDataSheet("17 Official Elections", data.official_elections, schema.official_elections, { widths: { election_name: 360, administering_authority: 330, geographic_scope: 330, notes: 520 } });
+const metricSheet = addDataSheet("18 Official Metrics", data.official_election_metrics, schema.official_election_metrics, { headerFill: colors.blue, widths: { source_label_original: 330, notes: 520 } });
+const turnoutSheet = addDataSheet("19 Turnout Wide", data.official_turnout, schema.official_turnout, { widths: { electorate_measure: 430, participation_measure: 360, turnout_numerator_measure: 360, notes: 540 } });
+const resultSheet = addDataSheet("20 Official Results", data.official_results, schema.official_results, { widths: { candidate_or_option: 360, party_or_affiliation: 290, ballot_designating_entity: 290, notes: 480 } });
+const officialSourceSheet = addDataSheet("21 Official Sources", data.official_data_sources, schema.official_data_sources, { widths: { electoral_institution: 330, title: 430, url: 430, landing_url: 430, download_url: 430, geographic_granularity: 350, notes: 500 } });
+
+const codebook = wb.worksheets.add("22 Codebook");
+codebook.showGridLines = false;
+const codebookRows = [
+  ["Concept", "Controlled value / rule", "Research meaning"],
+  ["record_layer", "claim_coded_core | screening_register | empirical_model_study", "These layers must never be counted together as incidents."],
+  ["record_type", "election_wide_case | observed_network | observed_incident | observed_campaign_set | preparedness_file", "Defines the unit. Preparedness is context, not an incident."],
+  ["manipulation_assessment", "manipulation_confirmed | mixed_documented_manipulation | transparent_contested_use | preparedness_not_incident", "AI use alone does not prove manipulation."],
+  ["claim_status", "supported | supported_as_attributed_measurement | partly_supported | unresolved", "Status of the claim as worded."],
+  ["evidence_strength", "high | moderate | low | none", "Evidence at claim level; numeric confidence is coder confidence in the label, not truth probability."],
+  ["agency_transfer_status", "full_chain_observed | partial_chain_observed | mechanism_observed_effect_unknown | mechanism_inferred | plausible_hypothesis | no_transfer_observed | insufficient_evidence | not_an_incident", "Separates observed control shift from outcome evidence."],
+  ["observations", "one measured quantity per row", "Never sum views, followers, calls, accounts, users or voters without compatible units and denominators."],
+  ["causal_status", "descriptive_only | association_only | causal estimates only with a design", "Official results and platform metrics are descriptive unless a causal design is recorded."],
+  ["model_evaluations", "study-specific unit, N, design, metrics and scope", "Capability evidence is not incident prevalence or real-world electoral effect."],
+  ["official turnout", "turnout_numerator + explicit measure", "For Moldova 2024, legal validity uses protocol C; D remains the participation count. For Moldova 2025 parliament, the official rate uses D."],
+  ["official result coverage", "complete_national_contest | complete | partial", "New Hampshire remains partial; complete groups reconcile to valid votes."],
+  ["missingness", "blank cell", "Use the literal unknown only when it is a controlled category."],
+  ["legacy multi-values", "pipe-delimited", "Prefer normalized claim_evidence, analytic_record_claims, case_elections and election_sources for joins."],
+  ["central prohibition", "no global prevalence or votes-changed estimate", "Sampling is purposive and most behavioural/electoral effects remain unknown."]
+];
+codebook.getRange(`A1:C${codebookRows.length}`).values = codebookRows;
+codebook.getRange("A1:C1").format = { fill: colors.charcoal, font: { bold: true, color: colors.white } };
+codebook.getRange(`A2:C${codebookRows.length}`).format = { borders: { preset: "all", style: "thin", color: "#D9DEE3" }, wrapText: true, verticalAlignment: "top" };
+codebook.getRange(`A2:C${codebookRows.length}`).format.rowHeightPx = 66;
+codebook.getRange(`A1:A${codebookRows.length}`).format.columnWidthPx = 230;
+codebook.getRange(`B1:B${codebookRows.length}`).format.columnWidthPx = 420;
+codebook.getRange(`C1:C${codebookRows.length}`).format.columnWidthPx = 550;
+codebook.freezePanes.freezeRows(1);
+
+const qa = wb.worksheets.add("23 QA");
+qa.showGridLines = false;
+qa.getRange("A1:D2").merge();
+qa.getRange("A1:D2").values = [["Release quality assurance"]];
+qa.getRange("A1:D2").format = { fill: colors.ink, font: { bold: true, color: colors.white, size: 17 }, verticalAlignment: "center" };
+qa.getRange("A4:D4").values = [["Check", "Result", "Expected", "Interpretation"]];
+qa.getRange("A5:D16").values = [
+  ["Automated audit status", audit.status.toUpperCase(), "PASS", "Deterministic v0.3 audit."],
+  ["Blocking errors", audit.summary.error_count, 0, "Must remain zero."],
+  ["Sampling-frame warnings", audit.summary.warning_count, 6, "Expected until negative searches are recorded in six frames."],
+  ["Research-view rows", data.research_view.length, data.pathways.length, "One row per pathway."],
+  ["Preparedness counted as incident", data.case_catalog.filter((r) => r.record_type === "preparedness_file" && r.incident_count_eligible === "true").length, 0, "Must remain zero."],
+  ["Model studies counted as incident", data.case_catalog.filter((r) => r.record_layer === "empirical_model_study" && r.incident_count_eligible === "true").length, 0, "Must remain zero."],
+  ["Claims without normalized evidence", data.claims.filter((r) => r.evidence_label !== "open_question" && !data.claim_evidence.some((e) => e.claim_id === r.claim_id)).length, 0, "Must remain zero."],
+  ["Typed observations", data.observations.length, stats.observations, "Must match generated stats."],
+  ["Complete RO/MD result groups", data.official_results.filter((r) => r.coverage_status === "complete_national_contest").length, 59, "Complete national candidate/party fields."],
+  ["Moldova legal-metric rows", data.official_election_metrics.filter((r) => r.geographic_unit_code === "MDA").length, 42, "Fields A–J and derived legal/participation rates."],
+  ["New Hampshire contest gap", data.official_election_metrics.find((r) => r.metric_code === "ballot_minus_contest_vote_gap")?.value || "", 1815, "Unclassified; not relabelled invalid/undervote."],
+  ["Release cutoff", "2026-08-12", "2026-08-12", "No later evidence is implied."]
+];
+qa.getRange("A4:D4").format = { fill: colors.charcoal, font: { bold: true, color: colors.white } };
+qa.getRange("A5:D16").format = { borders: { preset: "all", style: "thin", color: "#D9DEE3" }, wrapText: true, verticalAlignment: "top" };
+qa.getRange("A18:D21").merge();
+qa.getRange("A18:D21").values = [["Warnings are not failed checks. They deliberately block prevalence claims: the package records a null/negative search for South America, but not systematic negative searches for Europe, North America, Asia, Africa, Oceania or the cross-national study layer."]];
+qa.getRange("A18:D21").format = { fill: colors.paleAmber, font: { bold: true, color: colors.amber }, borders: { preset: "all", style: "thin", color: colors.amber }, wrapText: true, verticalAlignment: "top" };
+for (const [column, width] of [["A", 330], ["B", 180], ["C", 180], ["D", 520]]) qa.getRange(`${column}1:${column}22`).format.columnWidthPx = width;
+qa.freezePanes.freezeRows(4);
+
+for (const [meta, column, values] of [
+  [catalogSheet, "incident_count_eligible", ["TRUE", "FALSE"]],
+  [pathwaySheet, "assessment_label", ["established_evidence", "strong_inference", "plausible_hypothesis", "speculative_scenario", "open_question", "not_applicable"]],
+  [claimSheet, "evidence_strength", ["high", "moderate", "low", "none"]],
+  [claimSheet, "claim_status", ["supported", "supported_as_attributed_measurement", "partly_supported", "unresolved"]],
+  [sourceSheet, "source_quality", ["A", "B", "C", "D"]],
+  [electionSheet, "election_status", ["completed", "scheduled", "conditional"]],
+  [resultSheet, "coverage_status", ["complete_national_contest", "complete", "partial"]]
+]) {
+  const index = meta.columns.indexOf(column);
+  if (index >= 0 && meta.lastRow >= 2) {
+    const letter = excelColumn(index);
+    meta.sheet.getRange(`${letter}2:${letter}${meta.lastRow}`).dataValidation = { rule: { type: "list", values } };
+  }
+}
+
+const renderSheets = [
+  "00 Overview", "01 Research View", "02 Case Catalog", "03 Coverage", "04 Pathways", "05 Observations",
+  "06 Model Studies", "07 Claims", "08 Sources", "09 Claim Evidence", "10 Events", "11 Actors",
+  "12 Technology", "13 Content", "14 Cases Detail", "15 Screening Leads", "16 Watchlist",
+  "17 Official Elections", "18 Official Metrics", "19 Turnout Wide", "20 Official Results",
+  "21 Official Sources", "22 Codebook", "23 QA"
+];
+for (const sheetName of renderSheets) {
+  const preview = await wb.render({ sheetName, autoCrop: "all", scale: ["00 Overview", "03 Coverage", "23 QA"].includes(sheetName) ? 0.8 : 0.34, format: "png" });
+  await fs.writeFile(path.join(previewDir, `${sheetName.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-")}.png`), new Uint8Array(await preview.arrayBuffer()));
+}
+
+const inspection = await wb.inspect({ kind: "workbook,sheet,table,formula", maxChars: 18000, tableMaxRows: 4, tableMaxCols: 9, tableMaxCellChars: 90 });
+await fs.writeFile(path.join(outputDir, "inspection.ndjson"), inspection.ndjson || String(inspection));
+const verification = [];
+for (const range of ["00 Overview!A1:H29", "01 Research View!A1:Q11", "03 Coverage!A1:E8", "18 Official Metrics!A1:Q20", "23 QA!A1:D21"]) {
+  const result = await wb.inspect({ kind: "table", range, include: "values,formulas", tableMaxRows: 30, tableMaxCols: 20 });
+  verification.push(result.ndjson || String(result));
+}
+const formulaErrors = await wb.inspect({ kind: "match", searchTerm: "#REF!|#DIV/0!|#VALUE!|#NAME\\?|#N/A", options: { useRegex: true, maxResults: 300 }, summary: "final formula error scan" });
+verification.push(formulaErrors.ndjson || String(formulaErrors));
+await fs.writeFile(path.join(outputDir, "verification.ndjson"), verification.join("\n"));
+
+const outputPath = path.join(outputDir, "agency-transfer-election-evidence-index-v0.3.0.xlsx");
+const output = await SpreadsheetFile.exportXlsx(wb);
+await output.save(outputPath);
+process.stdout.write(`${outputPath}\n`);