Publish strict v0.3.1 builders and 26-table validation

Deterministic audit now validates 26 tables, 382 fields, 23 primary keys, 29 foreign keys, controlled vocabularies and electoral arithmetic.

scripts/audit-v03.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * Deterministic, read-only acceptance audit for the v0.3 CSV release.
+ * Deterministic, read-only integrity and semantic audit for the v0.3.1 CSV release.
  *
  * Usage:
  *   node scripts/audit-v03.mjs [data-directory]
@@ -18,12 +18,22 @@ 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 EXPECTED_TABLES = Object.freeze([
+  "cases", "claims", "sources", "events", "case_sources", "watchlist", "candidates",
+  "official_elections", "official_turnout", "official_results", "official_data_sources",
+  "official_election_metrics", "research_view", "case_catalog", "case_actors",
+  "technology_uses", "content_items", "pathways", "observations", "model_evaluations",
+  "claim_evidence", "analytic_record_claims", "case_elections", "election_sources",
+  "sampling_frame", "coverage_summary"
+]);
+
 const blocking = [];
 const advisory = [];
 const loaded = new Map();
 
 function issue(severity, test, code, table, rowId, message) {
   const item = {
+    layer: test.startsWith("T00_") ? "integrity" : "semantic",
     test,
     code,
     table: table || null,
@@ -36,6 +46,46 @@ function issue(severity, test, code, table, rowId, message) {
 const error = (...args) => issue("error", ...args);
 const warn = (...args) => issue("warning", ...args);
 
+const datapackagePath = path.join(dataDir, "datapackage.json");
+let datapackage = null;
+if (!fs.existsSync(datapackagePath)) {
+  error("T00_DATAPACKAGE", "DATAPACKAGE_MISSING", "datapackage", null, "data/datapackage.json is missing");
+} else {
+  try {
+    datapackage = JSON.parse(fs.readFileSync(datapackagePath, "utf8"));
+  } catch (caught) {
+    error("T00_DATAPACKAGE", "DATAPACKAGE_INVALID_JSON", "datapackage", null, `Invalid JSON: ${caught.message}`);
+  }
+}
+
+const resourceByName = new Map();
+if (datapackage && !Array.isArray(datapackage.resources)) {
+  error("T00_DATAPACKAGE", "RESOURCES_NOT_ARRAY", "datapackage", null, "resources must be an array");
+} else {
+  for (const [position, resource] of (datapackage?.resources || []).entries()) {
+    const name = String(resource?.name || "").trim();
+    if (!name) {
+      error("T00_DATAPACKAGE", "RESOURCE_NAME_MISSING", "datapackage", `resource:${position}`, "Resource name is blank");
+      continue;
+    }
+    if (resourceByName.has(name)) {
+      error("T00_DATAPACKAGE", "RESOURCE_DUPLICATE", "datapackage", name, `Duplicate resource: ${name}`);
+      continue;
+    }
+    resourceByName.set(name, resource);
+  }
+}
+for (const name of EXPECTED_TABLES) {
+  if (datapackage && !resourceByName.has(name)) {
+    error("T00_DATAPACKAGE", "RESOURCE_MISSING", "datapackage", name, `Expected resource is not declared: ${name}`);
+  }
+}
+for (const name of [...resourceByName.keys()].sort()) {
+  if (!EXPECTED_TABLES.includes(name)) {
+    error("T00_DATAPACKAGE", "RESOURCE_UNEXPECTED", "datapackage", name, `Unexpected tabular resource: ${name}`);
+  }
+}
+
 function parseCsv(text, filename) {
   const input = text.replace(/^\uFEFF/, "");
   const records = [];
@@ -148,6 +198,12 @@ const requiredColumns = {
   ],
   claims: ["claim_id", "case_id", "claim_type", "evidence_label", "source_ids"],
   sources: ["source_id", "source_type", "publication_date", "retrieved_at"],
+  events: ["event_id", "case_id", "event_date", "event_type", "description", "claim_ids", "source_ids", "event_status"],
+  case_sources: ["case_id", "source_id", "source_role", "supports_claim_types", "notes"],
+  watchlist: [
+    "watch_id", "case_id", "jurisdiction", "election_date", "monitoring_window", "signal_category",
+    "observable_indicator", "defensive_data_source", "assessment_rule", "status", "last_checked", "notes"
+  ],
   candidates: ["candidate_id", "region", "research_status"],
   case_catalog: [
     "catalog_id", "record_layer", "record_type", "manipulation_assessment",
@@ -206,23 +262,55 @@ const requiredColumns = {
     "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"
-  ]
+  ],
+  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"
+  ],
+  analytic_record_claims: ["record_claim_id", "record_type", "record_id", "case_id", "claim_id", "relation"],
+  election_sources: ["election_source_id", "election_id", "official_source_id", "source_role"]
 };
 
-for (const [name, headers] of Object.entries(requiredColumns)) loadTable(name, headers);
+const csvFiles = fs.existsSync(dataDir)
+  ? fs.readdirSync(dataDir).filter((filename) => filename.endsWith(".csv")).map((filename) => filename.slice(0, -4)).sort()
+  : [];
+for (const name of csvFiles) {
+  if (!EXPECTED_TABLES.includes(name)) {
+    error("T00_SCHEMA", "CSV_TABLE_UNEXPECTED", name, null, `${name}.csv is not one of the 26 release tables`);
+  }
+}
+for (const name of EXPECTED_TABLES) {
+  const schemaFields = resourceByName.get(name)?.schema?.fields;
+  const declaredHeaders = Array.isArray(schemaFields)
+    ? schemaFields.map((field) => String(field?.name || "").trim()).filter(Boolean)
+    : [];
+  loadTable(name, [...new Set([...(requiredColumns[name] || []), ...declaredHeaders])]);
+}
 
 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 isIsoDate(value) {
+  const text = clean(value);
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(text);
+  if (!match) return false;
+  const parsed = new Date(`${text}T00:00:00.000Z`);
+  return !Number.isNaN(parsed.valueOf()) &&
+    parsed.getUTCFullYear() === Number(match[1]) &&
+    parsed.getUTCMonth() + 1 === Number(match[2]) &&
+    parsed.getUTCDate() === Number(match[3]);
+}
 
 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"
+    "claim_evidence_id", "record_claim_id", "case_election_id", "election_source_id", "watch_id",
+    "metric_id", "event_id", "case_id", "pathway_id", "observation_id", "evaluation_id", "frame_id",
+    "catalog_id", "result_id", "turnout_id", "election_id", "official_source_id", "source_id", "claim_id"
   ];
   for (const field of likely) if (!isBlank(row[field])) return clean(row[field]);
   return `line:${row.__line}`;
@@ -234,15 +322,209 @@ function requireNonBlank(row, fields, test, table, id) {
   }
 }
 
+const EXPECTED_PRIMARY_KEYS = Object.freeze({
+  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"
+});
+
+function normalizedFields(value) {
+  if (typeof value === "string") return value.trim() ? [value.trim()] : [];
+  if (Array.isArray(value)) return value.map((field) => String(field || "").trim()).filter(Boolean);
+  return [];
+}
+
+function typedValue(value, type) {
+  const text = clean(value);
+  if (type === "string") return { valid: true, value: String(value ?? "") };
+  if (type === "integer") {
+    if (!/^[+-]?\d+$/.test(text)) return { valid: false, value: null };
+    const number = Number(text);
+    return { valid: Number.isSafeInteger(number), value: number };
+  }
+  if (type === "number") {
+    if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(text)) return { valid: false, value: null };
+    const number = Number(text);
+    return { valid: Number.isFinite(number), value: number };
+  }
+  if (type === "boolean") {
+    if (!/^(true|false)$/i.test(text)) return { valid: false, value: null };
+    return { valid: true, value: lower(text) === "true" };
+  }
+  if (type === "date") return { valid: isIsoDate(text), value: text };
+  return { valid: false, value: null, unsupported: true };
+}
+
+// T00 — datapackage.json is the executable integrity contract for all 26 tables.
+for (const name of EXPECTED_TABLES) {
+  const resource = resourceByName.get(name);
+  if (!resource) continue;
+  if (clean(resource.path) !== `${name}.csv`) {
+    error("T00_DATAPACKAGE", "RESOURCE_PATH_MISMATCH", "datapackage", name, `Expected path ${name}.csv; found ${clean(resource.path) || "blank"}`);
+  }
+  if (!resource.schema || !Array.isArray(resource.schema.fields)) {
+    error("T00_DATAPACKAGE", "SCHEMA_FIELDS_MISSING", "datapackage", name, "Resource schema.fields must be an array");
+    continue;
+  }
+
+  const fieldNames = [];
+  const fieldByName = new Map();
+  for (const [position, field] of resource.schema.fields.entries()) {
+    const fieldName = clean(field?.name);
+    if (!fieldName) {
+      error("T00_DATAPACKAGE", "FIELD_NAME_MISSING", "datapackage", `${name}:${position}`, "Schema field name is blank");
+      continue;
+    }
+    if (fieldByName.has(fieldName)) {
+      error("T00_DATAPACKAGE", "FIELD_DUPLICATE", "datapackage", `${name}:${fieldName}`, `Duplicate schema field: ${fieldName}`);
+    }
+    fieldNames.push(fieldName);
+    fieldByName.set(fieldName, field);
+  }
+
+  const table = loaded.get(name);
+  if (table?.exists && (
+    table.headers.length !== fieldNames.length ||
+    table.headers.some((header, position) => header !== fieldNames[position])
+  )) {
+    error(
+      "T00_DATAPACKAGE", "HEADER_SCHEMA_MISMATCH", name, null,
+      `CSV header/order differs from datapackage schema (CSV ${table.headers.length} fields; schema ${fieldNames.length})`
+    );
+  }
+
+  const expectedPrimaryKey = EXPECTED_PRIMARY_KEYS[name];
+  const declaredPrimaryKey = normalizedFields(resource.schema.primaryKey);
+  if (expectedPrimaryKey && (declaredPrimaryKey.length !== 1 || declaredPrimaryKey[0] !== expectedPrimaryKey)) {
+    error(
+      "T00_DATAPACKAGE", "PRIMARY_KEY_DECLARATION_MISMATCH", "datapackage", name,
+      `Expected primaryKey=${expectedPrimaryKey}; found ${declaredPrimaryKey.join("|") || "none"}`
+    );
+  }
+  if (!expectedPrimaryKey && declaredPrimaryKey.length) {
+    error("T00_DATAPACKAGE", "PRIMARY_KEY_UNEXPECTED", "datapackage", name, `Unexpected primary key declaration: ${declaredPrimaryKey.join("|")}`);
+  }
+  for (const fieldName of declaredPrimaryKey) {
+    if (!fieldByName.has(fieldName)) {
+      error("T00_DATAPACKAGE", "PRIMARY_KEY_FIELD_UNKNOWN", "datapackage", name, `primaryKey references undeclared field: ${fieldName}`);
+    }
+  }
+
+  for (const [fieldName, field] of fieldByName) {
+    const type = clean(field.type);
+    if (!["string", "integer", "number", "boolean", "date"].includes(type)) {
+      error("T00_DATAPACKAGE", "FIELD_TYPE_UNSUPPORTED", "datapackage", `${name}:${fieldName}`, `Unsupported or blank field type: ${type || "blank"}`);
+      continue;
+    }
+    const constraints = field.constraints && typeof field.constraints === "object" ? field.constraints : {};
+    const seenUnique = new Set();
+    for (const row of table?.rows || []) {
+      const id = rowId(row, name);
+      const raw = row[fieldName];
+      if (isBlank(raw)) {
+        if (constraints.required === true) {
+          error("T00_TYPES", "REQUIRED_CONSTRAINT_VIOLATION", name, id, `${fieldName} is required by datapackage.json`);
+        }
+        continue;
+      }
+      const parsed = typedValue(raw, type);
+      if (!parsed.valid) {
+        error(
+          "T00_TYPES", type === "date" ? "DATE_TYPE_INVALID" : "FIELD_TYPE_INVALID", name, id,
+          `${fieldName}=${JSON.stringify(clean(raw))} is not a valid ${type}`
+        );
+        continue;
+      }
+      if (Array.isArray(constraints.enum) && !constraints.enum.map(String).includes(String(parsed.value))) {
+        error("T00_TYPES", "ENUM_CONSTRAINT_VIOLATION", name, id, `${fieldName} is outside the datapackage enum constraint`);
+      }
+      if (typeof constraints.pattern === "string") {
+        try {
+          if (!new RegExp(constraints.pattern).test(clean(raw))) {
+            error("T00_TYPES", "PATTERN_CONSTRAINT_VIOLATION", name, id, `${fieldName} does not match its datapackage pattern`);
+          }
+        } catch {
+          error("T00_DATAPACKAGE", "PATTERN_CONSTRAINT_INVALID", "datapackage", `${name}:${fieldName}`, "Invalid regular expression in field constraint");
+        }
+      }
+      if (typeof parsed.value === "number") {
+        if (Number.isFinite(constraints.minimum) && parsed.value < constraints.minimum) {
+          error("T00_TYPES", "MINIMUM_CONSTRAINT_VIOLATION", name, id, `${fieldName} is below ${constraints.minimum}`);
+        }
+        if (Number.isFinite(constraints.maximum) && parsed.value > constraints.maximum) {
+          error("T00_TYPES", "MAXIMUM_CONSTRAINT_VIOLATION", name, id, `${fieldName} exceeds ${constraints.maximum}`);
+        }
+      }
+      if (constraints.unique === true) {
+        const key = String(parsed.value);
+        if (seenUnique.has(key)) error("T00_TYPES", "UNIQUE_CONSTRAINT_VIOLATION", name, id, `${fieldName} duplicates ${key}`);
+        seenUnique.add(key);
+      }
+    }
+  }
+}
+
+// Validate every foreign key declared in the datapackage, rather than a hand-picked subset.
+for (const name of EXPECTED_TABLES) {
+  const resource = resourceByName.get(name);
+  const foreignKeys = resource?.schema?.foreignKeys;
+  if (foreignKeys !== undefined && !Array.isArray(foreignKeys)) {
+    error("T00_FOREIGN_KEYS", "FOREIGN_KEYS_NOT_ARRAY", "datapackage", name, "schema.foreignKeys must be an array");
+    continue;
+  }
+  for (const [position, foreignKey] of (foreignKeys || []).entries()) {
+    const localFields = normalizedFields(foreignKey?.fields);
+    const targetName = clean(foreignKey?.reference?.resource);
+    const targetFields = normalizedFields(foreignKey?.reference?.fields);
+    const declarationId = `${name}:foreignKey:${position}`;
+    if (!localFields.length || localFields.length !== targetFields.length || !targetName) {
+      error("T00_FOREIGN_KEYS", "FOREIGN_KEY_DECLARATION_INVALID", "datapackage", declarationId, "Foreign key needs equally sized local/reference fields and a target resource");
+      continue;
+    }
+    const localHeaders = new Set(loaded.get(name)?.headers || []);
+    const targetTable = loaded.get(targetName);
+    const targetHeaders = new Set(targetTable?.headers || []);
+    for (const fieldName of localFields) {
+      if (!localHeaders.has(fieldName)) error("T00_FOREIGN_KEYS", "FOREIGN_KEY_LOCAL_FIELD_UNKNOWN", "datapackage", declarationId, `Unknown local field: ${fieldName}`);
+    }
+    if (!resourceByName.has(targetName) || !targetTable?.exists) {
+      error("T00_FOREIGN_KEYS", "FOREIGN_KEY_RESOURCE_UNKNOWN", "datapackage", declarationId, `Unknown target resource: ${targetName}`);
+      continue;
+    }
+    for (const fieldName of targetFields) {
+      if (!targetHeaders.has(fieldName)) error("T00_FOREIGN_KEYS", "FOREIGN_KEY_TARGET_FIELD_UNKNOWN", "datapackage", declarationId, `Unknown target field: ${targetName}.${fieldName}`);
+    }
+    if (localFields.some((field) => !localHeaders.has(field)) || targetFields.some((field) => !targetHeaders.has(field))) continue;
+    const targetKeys = new Set(targetTable.rows.map((row) => targetFields.map((field) => clean(row[field])).join("\u001f")));
+    for (const row of rows(name)) {
+      const values = localFields.map((field) => clean(row[field]));
+      if (values.every((value) => !value)) continue;
+      if (values.some((value) => !value)) {
+        error("T00_FOREIGN_KEYS", "FOREIGN_KEY_PARTIAL", name, rowId(row, name), `Partially blank foreign key: ${localFields.join("|")}`);
+      } else if (!targetKeys.has(values.join("\u001f"))) {
+        error(
+          "T00_FOREIGN_KEYS", "FOREIGN_KEY_UNKNOWN", name, rowId(row, name),
+          `${localFields.join("|")} references unknown ${targetName}.${targetFields.join("|")}: ${values.join("|")}`
+        );
+      }
+    }
+  }
+}
+
 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}`);
+      error("T00_RELATIONAL_INTEGRITY", "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}`);
+      error("T00_RELATIONAL_INTEGRITY", "PRIMARY_KEY_DUPLICATE", table, id, `Duplicate ${field}: ${id}`);
     } else {
       index.set(id, row);
     }
@@ -250,15 +532,7 @@ function uniqueIndex(table, field) {
   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 primaryKeys = { ...EXPECTED_PRIMARY_KEYS };
 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) {
@@ -279,6 +553,84 @@ const caseFamilyIds = new Set(rows("cases").map((row) => clean(row.case_family_i
 const cutoffCandidates = rows("cases").map((row) => clean(row.as_of_date)).filter(isIsoDate).sort();
 const cutoff = cutoffCandidates.at(-1) || null;
 
+const DOCUMENTED_ENUMS = Object.freeze({
+  "cases.case_status": ["retrospective", "ongoing", "prospective_monitoring"],
+  "cases.record_type": ["election_wide_case", "observed_network", "observed_incident", "observed_campaign_set", "preparedness_file"],
+  "cases.manipulation_assessment": [
+    "manipulation_confirmed", "manipulation_probable", "mixed_documented_manipulation",
+    "transparent_contested_use", "manipulation_not_established", "no_manipulation_observed",
+    "preparedness_not_incident", "not_an_incident", "not_yet_claim_coded"
+  ],
+  "cases.ai_role": ["core_generation", "material_amplification", "supporting_tool", "detection_response", "none_established", "mixed"],
+  "cases.generative_ai_status": ["confirmed", "probable", "alleged", "not_established", "not_applicable"],
+  "cases.occurrence_status": ["confirmed", "partly_confirmed", "alleged", "not_observed"],
+  "cases.behavioural_effect_status": ["measured", "indicated", "not_detected", "unknown"],
+  "cases.electoral_effect_status": ["measured", "institutionally_asserted", "not_detected", "unknown"],
+  "case_catalog.record_layer": ["claim_coded_core", "screening_register", "empirical_model_study"],
+  "case_catalog.record_type": [
+    "election_wide_case", "observed_network", "observed_incident", "observed_campaign_set",
+    "preparedness_file", "candidate_lead", "model_evaluation_or_experiment"
+  ],
+  "case_catalog.manipulation_assessment": [
+    "manipulation_confirmed", "manipulation_probable", "mixed_documented_manipulation",
+    "transparent_contested_use", "manipulation_not_established", "no_manipulation_observed",
+    "preparedness_not_incident", "not_an_incident", "not_yet_claim_coded"
+  ],
+  "claims.claim_type": [
+    "occurrence", "mechanism", "ai_role", "reach", "attribution", "intent", "behavioural_effect",
+    "electoral_effect", "institutional_outcome", "response", "legal_status", "counterevidence", "agency_transfer"
+  ],
+  "claims.evidence_label": ["established_evidence", "established_as_campaign_report", "strong_inference", "open_question"],
+  "claims.claim_status": ["supported", "supported_as_attributed_measurement", "partly_supported", "unresolved"],
+  "claims.evidence_strength": ["high", "moderate", "low", "none"],
+  "claim_evidence.relation": ["supports", "counterevidence", "qualifies"],
+  "claim_evidence.evidence_scope": ["underlying_fact", "assertion_was_made", "institutional_action", "measurement", "researcher_inference"],
+  "claim_evidence.directness": ["firsthand_artifact_or_measurement", "official_record_or_allegation", "independent_secondary_reporting"],
+  "sources.source_quality": ["A", "B", "C", "D"],
+  "sources.source_independence": ["independent_or_official", "independent_secondary", "interested_or_mixed", "unknown"],
+  "sources.method_transparency": [
+    "sufficiently_described_or_reproducible", "not_applicable_official_record",
+    "limited_to_published_account", "opaque"
+  ],
+  "case_actors.attribution_status": [
+    "admitted", "adjudicated", "officially_attributed", "platform_attributed",
+    "credibly_reported", "alleged", "unknown", "mixed"
+  ],
+  "pathways.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"
+  ],
+  "pathways.assessment_label": [
+    "established_evidence", "strong_inference", "plausible_hypothesis",
+    "speculative_scenario", "open_question", "not_applicable"
+  ],
+  "observations.causal_status": [
+    "descriptive_only", "association_only", "experimental_causal_estimate",
+    "quasi_experimental_causal_estimate", "causal_estimate", "not_applicable"
+  ],
+  "sampling_frame.search_status": ["complete", "systematic", "substantial", "partial", "ongoing", "not_started"],
+  "official_elections.election_status": ["completed", "scheduled", "conditional"],
+  "official_results.coverage_status": ["complete_national_contest", "complete", "partial"]
+});
+
+for (const [qualifiedField, allowedValues] of Object.entries(DOCUMENTED_ENUMS)) {
+  const separator = qualifiedField.indexOf(".");
+  const table = qualifiedField.slice(0, separator);
+  const field = qualifiedField.slice(separator + 1);
+  const allowed = new Set(allowedValues);
+  for (const row of rows(table)) {
+    const value = clean(row[field]);
+    if (!value) {
+      error("T13_DOCUMENTED_ENUMS", "DOCUMENTED_ENUM_BLANK", table, rowId(row, table), `${field} must use a documented value`);
+    } else if (!allowed.has(value)) {
+      error(
+        "T13_DOCUMENTED_ENUMS", "DOCUMENTED_ENUM_INVALID", table, rowId(row, table),
+        `${field}=${JSON.stringify(value)} is not in the documented vocabulary`
+      );
+    }
+  }
+}
+
 // T01 — every included case has an explicit, controlled record classification.
 const validRecordTypes = new Set([
   "observed_incident", "observed_network", "observed_campaign_set", "election_wide_case",
@@ -434,7 +786,7 @@ for (const row of rows("official_elections")) {
     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 table of ["official_turnout", "official_results", "official_election_metrics"]) {
   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");
@@ -943,7 +1295,7 @@ for (const row of rows("coverage_summary")) {
   }
 }
 
-// Normalized v0.3 joins must cover legacy pipe lists; this catches silent evidence loss.
+// Normalized v0.3.1 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")) {
@@ -988,6 +1340,330 @@ for (const caseRow of rows("cases")) {
   }
 }
 
+// T14 — explicit semantics for the six tables that earlier auditors loaded incompletely or not at all.
+function uniqueComposite(table, fields, test = "T14_TABLE_SEMANTICS") {
+  const seen = new Set();
+  for (const row of rows(table)) {
+    const values = fields.map((field) => clean(row[field]));
+    if (values.some((value) => !value)) continue;
+    const key = values.join("::");
+    if (seen.has(key)) {
+      error(test, "COMPOSITE_KEY_DUPLICATE", table, rowId(row, table), `Duplicate ${fields.join("+")}: ${key}`);
+    }
+    seen.add(key);
+  }
+  return seen;
+}
+
+const documentedClaimTypes = new Set(DOCUMENTED_ENUMS["claims.claim_type"]);
+const caseSourceRoles = new Set(["primary_record", "corroboration", "counterevidence", "context", "methodology", "ongoing_monitoring"]);
+const caseSourcePairs = uniqueComposite("case_sources", ["case_id", "source_id"]);
+for (const row of rows("case_sources")) {
+  const id = rowId(row, "case_sources");
+  requireNonBlank(row, ["case_id", "source_id", "source_role"], "T14_TABLE_SEMANTICS", "case_sources", id);
+  if (!caseSourceRoles.has(clean(row.source_role))) {
+    error("T14_TABLE_SEMANTICS", "CASE_SOURCE_ROLE_INVALID", "case_sources", id, `Unknown source_role: ${clean(row.source_role)}`);
+  }
+  const caseClaimTypes = new Set(rows("claims").filter((claim) => clean(claim.case_id) === clean(row.case_id)).map((claim) => clean(claim.claim_type)));
+  for (const claimType of ids(row.supports_claim_types)) {
+    if (!documentedClaimTypes.has(claimType)) {
+      error("T14_TABLE_SEMANTICS", "CASE_SOURCE_CLAIM_TYPE_INVALID", "case_sources", id, `Unknown supports_claim_types token: ${claimType}`);
+    } else if (!caseClaimTypes.has(claimType)) {
+      warn("T14_TABLE_SEMANTICS", "CASE_SOURCE_CLAIM_TYPE_ORPHAN", "case_sources", id, `No ${claimType} claim exists for this case; verify or narrow supports_claim_types`);
+    }
+  }
+}
+for (const claim of rows("claims")) {
+  requireFk("T03_FOREIGN_KEYS", "claims", claim, "source_ids", "sources", index.sources, true);
+  requireFk("T03_FOREIGN_KEYS", "claims", claim, "counter_source_ids", "sources", index.sources, true);
+  if (
+    !ids(claim.source_ids).length && !ids(claim.counter_source_ids).length &&
+    !(clean(claim.evidence_label) === "open_question" && clean(claim.evidence_strength) === "none" && clean(claim.claim_status) === "unresolved")
+  ) {
+    error("T14_TABLE_SEMANTICS", "CLAIM_WITHOUT_EVIDENCE_LINK", "claims", clean(claim.claim_id), "A claim without source or counter-source links must be an unresolved open question with evidence_strength=none");
+  }
+  for (const sourceId of [...ids(claim.source_ids), ...ids(claim.counter_source_ids)]) {
+    const pair = `${clean(claim.case_id)}::${sourceId}`;
+    if (!caseSourcePairs.has(pair)) {
+      error("T14_TABLE_SEMANTICS", "CLAIM_CASE_SOURCE_JOIN_MISSING", "case_sources", clean(claim.claim_id), `Claim source is absent from case_sources.csv: ${sourceId}`);
+    }
+  }
+}
+
+const eventStatuses = new Set(["observed", "contested", "prospective"]);
+for (const row of rows("events")) {
+  const id = rowId(row, "events");
+  requireNonBlank(row, ["case_id", "event_date", "event_type", "description", "source_ids", "event_status"], "T14_TABLE_SEMANTICS", "events", id);
+  requireFk("T03_FOREIGN_KEYS", "events", row, "claim_ids", "claims", index.claims, true);
+  requireFk("T03_FOREIGN_KEYS", "events", row, "source_ids", "sources");
+  if (!eventStatuses.has(clean(row.event_status))) {
+    error("T14_TABLE_SEMANTICS", "EVENT_STATUS_INVALID", "events", id, `Unknown event_status: ${clean(row.event_status)}`);
+  }
+  for (const claimId of ids(row.claim_ids)) {
+    const claim = index.claims.get(claimId);
+    if (claim && clean(claim.case_id) !== clean(row.case_id)) {
+      error("T14_TABLE_SEMANTICS", "EVENT_CROSS_CASE_CLAIM", "events", id, `claim_ids references another case: ${claimId}`);
+    }
+  }
+  for (const sourceId of ids(row.source_ids)) {
+    if (!caseSourcePairs.has(`${clean(row.case_id)}::${sourceId}`)) {
+      error("T14_TABLE_SEMANTICS", "EVENT_CASE_SOURCE_JOIN_MISSING", "events", id, `Event source is absent from case_sources.csv: ${sourceId}`);
+    }
+  }
+  if (cutoff && isIsoDate(row.event_date) && clean(row.event_date) > cutoff && clean(row.event_status) !== "prospective") {
+    error("T14_TABLE_SEMANTICS", "FUTURE_EVENT_NOT_PROSPECTIVE", "events", id, `Event after cutoff ${cutoff} must be prospective`);
+  }
+}
+
+const watchStatuses = new Set(["active", "prospective_monitoring"]);
+for (const row of rows("watchlist")) {
+  const id = rowId(row, "watchlist");
+  requireNonBlank(
+    row,
+    [
+      "case_id", "jurisdiction", "election_date", "monitoring_window", "signal_category",
+      "observable_indicator", "defensive_data_source", "assessment_rule", "status", "last_checked"
+    ],
+    "T14_TABLE_SEMANTICS", "watchlist", id
+  );
+  if (!watchStatuses.has(clean(row.status))) {
+    error("T14_TABLE_SEMANTICS", "WATCH_STATUS_INVALID", "watchlist", id, `Unknown status: ${clean(row.status)}`);
+  }
+  if (cutoff && isIsoDate(row.last_checked) && clean(row.last_checked) > cutoff) {
+    error("T14_TABLE_SEMANTICS", "WATCH_CHECK_AFTER_CUTOFF", "watchlist", id, `last_checked is after dataset cutoff ${cutoff}`);
+  }
+  const linkedElectionDates = rows("case_elections")
+    .filter((join) => clean(join.case_id) === clean(row.case_id))
+    .map((join) => clean(index.official_elections.get(clean(join.election_id))?.election_date))
+    .filter(Boolean);
+  if (!linkedElectionDates.includes(clean(row.election_date))) {
+    error("T14_TABLE_SEMANTICS", "WATCH_ELECTION_DATE_UNLINKED", "watchlist", id, "election_date does not match an official election linked to the case");
+  }
+}
+
+const analyticTargets = Object.freeze({
+  case_actor: ["case_actors", "case_actor_id", "source_claim_ids"],
+  technology_use: ["technology_uses", "tech_use_id", "source_claim_ids"],
+  content_item: ["content_items", "content_item_id", "source_claim_ids"],
+  pathway: ["pathways", "pathway_id", "source_claim_ids"],
+  event: ["events", "event_id", "claim_ids"]
+});
+const analyticPairs = uniqueComposite("analytic_record_claims", ["record_type", "record_id", "claim_id"]);
+for (const row of rows("analytic_record_claims")) {
+  const id = rowId(row, "analytic_record_claims");
+  requireNonBlank(row, ["record_type", "record_id", "case_id", "claim_id", "relation"], "T14_TABLE_SEMANTICS", "analytic_record_claims", id);
+  const target = analyticTargets[clean(row.record_type)];
+  if (!target) {
+    error("T14_TABLE_SEMANTICS", "ANALYTIC_RECORD_TYPE_INVALID", "analytic_record_claims", id, `Unknown record_type: ${clean(row.record_type)}`);
+    continue;
+  }
+  if (clean(row.relation) !== "supports_coding") {
+    error("T14_TABLE_SEMANTICS", "ANALYTIC_RELATION_INVALID", "analytic_record_claims", id, `Unknown relation: ${clean(row.relation)}`);
+  }
+  const targetRow = index[target[0]]?.get(clean(row.record_id));
+  if (!targetRow) {
+    error("T14_TABLE_SEMANTICS", "ANALYTIC_RECORD_UNKNOWN", "analytic_record_claims", id, `${row.record_type} references unknown ${target[0]} row: ${clean(row.record_id)}`);
+  } else if (clean(targetRow.case_id) !== clean(row.case_id)) {
+    error("T14_TABLE_SEMANTICS", "ANALYTIC_RECORD_CASE_MISMATCH", "analytic_record_claims", id, "record_id belongs to another case");
+  }
+  const claim = index.claims.get(clean(row.claim_id));
+  if (claim && clean(claim.case_id) !== clean(row.case_id)) {
+    error("T14_TABLE_SEMANTICS", "ANALYTIC_CLAIM_CASE_MISMATCH", "analytic_record_claims", id, "claim_id belongs to another case");
+  }
+}
+for (const [recordType, [table, idField, claimField]] of Object.entries(analyticTargets)) {
+  for (const row of rows(table)) {
+    for (const claimId of ids(row[claimField])) {
+      const key = `${recordType}::${clean(row[idField])}::${claimId}`;
+      if (!analyticPairs.has(key)) {
+        error("T14_TABLE_SEMANTICS", "ANALYTIC_CLAIM_JOIN_MISSING", "analytic_record_claims", clean(row[idField]), `Legacy ${claimField} entry is absent from normalized join: ${claimId}`);
+      }
+    }
+  }
+}
+
+const caseElectionRelations = new Set(["primary_or_institutional_context", "future_or_campaign_context"]);
+uniqueComposite("case_elections", ["case_id", "election_id"]);
+for (const row of rows("case_elections")) {
+  if (!caseElectionRelations.has(clean(row.relation))) {
+    error("T14_TABLE_SEMANTICS", "CASE_ELECTION_RELATION_INVALID", "case_elections", rowId(row, "case_elections"), `Unknown relation: ${clean(row.relation)}`);
+  }
+}
+
+const electionSourcePairs = uniqueComposite("election_sources", ["election_id", "official_source_id"]);
+const electionSourceRoles = new Set([
+  "supports_election_context_or_status", "election_definition", "turnout", "results", "metrics", "legal_status"
+]);
+for (const row of rows("election_sources")) {
+  const id = rowId(row, "election_sources");
+  requireNonBlank(row, ["election_id", "official_source_id", "source_role"], "T14_TABLE_SEMANTICS", "election_sources", id);
+  if (!electionSourceRoles.has(clean(row.source_role))) {
+    error("T14_TABLE_SEMANTICS", "ELECTION_SOURCE_ROLE_INVALID", "election_sources", id, `Unknown source_role: ${clean(row.source_role)}`);
+  }
+  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("T14_TABLE_SEMANTICS", "ELECTION_SOURCE_FAMILY_MISMATCH", "election_sources", id, "Election and official source belong to different case families");
+  }
+  if (election && !ids(election.official_source_ids).includes(clean(row.official_source_id))) {
+    error("T14_TABLE_SEMANTICS", "ELECTION_SOURCE_NOT_RECIPROCAL", "election_sources", id, "Normalized link is absent from official_elections.official_source_ids");
+  }
+}
+for (const election of rows("official_elections")) {
+  for (const sourceId of ids(election.official_source_ids)) {
+    const pair = `${clean(election.election_id)}::${sourceId}`;
+    if (!electionSourcePairs.has(pair)) {
+      error("T14_TABLE_SEMANTICS", "ELECTION_SOURCE_JOIN_MISSING", "election_sources", pair, "Legacy official_source_ids entry is absent from election_sources.csv");
+    }
+  }
+}
+for (const table of ["official_turnout", "official_results", "official_election_metrics"]) {
+  for (const row of rows(table)) {
+    const pair = `${clean(row.election_id)}::${clean(row.official_source_id)}`;
+    if (!electionSourcePairs.has(pair)) {
+      error("T14_TABLE_SEMANTICS", "OFFICIAL_ROW_SOURCE_JOIN_MISSING", "election_sources", rowId(row, table), `${table} source/election pair is absent from election_sources.csv`);
+    }
+  }
+}
+
+const metricLookup = new Map();
+for (const row of rows("official_election_metrics")) {
+  const id = rowId(row, "official_election_metrics");
+  requireNonBlank(
+    row,
+    ["election_id", "geographic_unit_type", "metric_code", "value", "source_label_original", "legal_role", "data_status", "official_source_id", "as_of_date"],
+    "T14_TABLE_SEMANTICS", "official_election_metrics", id
+  );
+  const key = [row.election_id, row.geographic_unit_type, row.geographic_unit_code, row.metric_code].map(clean).join("::");
+  if (metricLookup.has(key)) {
+    error("T14_TABLE_SEMANTICS", "OFFICIAL_METRIC_DUPLICATE", "official_election_metrics", id, `Duplicate election/geography/metric_code: ${key}`);
+  }
+  metricLookup.set(key, row);
+  const value = parseNumber(row.value);
+  if (!Number.isFinite(value) || value < 0) {
+    error("T14_TABLE_SEMANTICS", "OFFICIAL_METRIC_VALUE_INVALID", "official_election_metrics", id, "value must be a non-negative finite number");
+  }
+  if (/rate|share/i.test(clean(row.metric_code)) && Number.isFinite(value) && value > 1) {
+    error("T14_TABLE_SEMANTICS", "OFFICIAL_METRIC_RATE_RANGE", "official_election_metrics", id, "Rate/share metric value must be between 0 and 1");
+  }
+  for (const field of ["authority_reported_rate", "computed_rate"]) {
+    if (!isBlank(row[field])) {
+      const rate = parseNumber(row[field]);
+      if (!Number.isFinite(rate) || rate < 0 || rate > 1) {
+        error("T14_TABLE_SEMANTICS", "OFFICIAL_METRIC_RATE_INVALID", "official_election_metrics", id, `${field} must be between 0 and 1`);
+      }
+    }
+  }
+  if (isBlank(row.numerator_metric) !== isBlank(row.denominator_metric)) {
+    error("T14_TABLE_SEMANTICS", "OFFICIAL_METRIC_COMPONENT_PARTIAL", "official_election_metrics", id, "numerator_metric and denominator_metric must be present together");
+  }
+  if (!officialDataStatuses.has(clean(row.data_status))) {
+    error("T14_TABLE_SEMANTICS", "OFFICIAL_METRIC_STATUS_INVALID", "official_election_metrics", id, `Unknown data_status: ${clean(row.data_status)}`);
+  }
+  if (cutoff && isIsoDate(row.as_of_date) && clean(row.as_of_date) > cutoff) {
+    error("T14_TABLE_SEMANTICS", "OFFICIAL_METRIC_AFTER_CUTOFF", "official_election_metrics", id, `as_of_date is after dataset cutoff ${cutoff}`);
+  }
+  const election = index.official_elections.get(clean(row.election_id));
+  if (cutoff && election && clean(election.election_date) > cutoff && clean(row.data_status) === "final") {
+    error("T14_TABLE_SEMANTICS", "FUTURE_FINAL_OFFICIAL_METRIC", "official_election_metrics", id, "Future election has final metric data");
+  }
+}
+function metricReferenceKey(row, metricCode) {
+  const normalizedCode = clean(metricCode) === "A+B" ? "A_plus_B" : clean(metricCode);
+  return [row.election_id, row.geographic_unit_type, row.geographic_unit_code, normalizedCode].map(clean).join("::");
+}
+function resolveMetricComponent(row, metricCode) {
+  const longMetric = metricLookup.get(metricReferenceKey(row, metricCode));
+  if (longMetric) return { value: longMetric.value, origin: "official_election_metrics" };
+  const field = clean(metricCode);
+  if (!loaded.get("official_turnout")?.headers.includes(field)) return null;
+  const matches = rows("official_turnout").filter(
+    (turnout) => clean(turnout.election_id) === clean(row.election_id) &&
+      clean(turnout.geographic_unit_type) === clean(row.geographic_unit_type) &&
+      clean(turnout.geographic_unit_code) === clean(row.geographic_unit_code) &&
+      !isBlank(turnout[field])
+  );
+  return matches.length === 1 ? { value: matches[0][field], origin: "official_turnout" } : null;
+}
+for (const row of rows("official_election_metrics")) {
+  if (isBlank(row.numerator_metric) && isBlank(row.denominator_metric)) continue;
+  const id = rowId(row, "official_election_metrics");
+  const numerator = resolveMetricComponent(row, row.numerator_metric);
+  const denominator = resolveMetricComponent(row, row.denominator_metric);
+  if (!numerator) {
+    error("T14_TABLE_SEMANTICS", "OFFICIAL_METRIC_NUMERATOR_UNKNOWN", "official_election_metrics", id, `Unknown numerator metric in the same election/geography: ${clean(row.numerator_metric)}`);
+  }
+  if (!denominator) {
+    error("T14_TABLE_SEMANTICS", "OFFICIAL_METRIC_DENOMINATOR_UNKNOWN", "official_election_metrics", id, `Unknown denominator metric in the same election/geography: ${clean(row.denominator_metric)}`);
+  }
+  if (!numerator || !denominator) continue;
+  const denominatorValue = parseNumber(denominator.value);
+  const expectedRate = denominatorValue > 0 ? parseNumber(numerator.value) / denominatorValue : Number.NaN;
+  const computedRate = parseNumber(row.computed_rate);
+  if (!Number.isFinite(computedRate)) {
+    error("T14_TABLE_SEMANTICS", "OFFICIAL_METRIC_COMPUTED_RATE_MISSING", "official_election_metrics", id, "Rate components require computed_rate");
+  } else if (!Number.isFinite(expectedRate) || Math.abs(computedRate - expectedRate) > 1e-12) {
+    error("T14_TABLE_SEMANTICS", "OFFICIAL_METRIC_RECOMPUTATION_MISMATCH", "official_election_metrics", id, `computed_rate=${computedRate}; numerator/denominator=${expectedRate}`);
+  }
+  const value = parseNumber(row.value);
+  if (Number.isFinite(computedRate) && Number.isFinite(value) && Math.abs(value - computedRate) > 1e-12) {
+    error("T14_TABLE_SEMANTICS", "OFFICIAL_METRIC_VALUE_RATE_MISMATCH", "official_election_metrics", id, "Rate metric value differs from computed_rate");
+  }
+  const authorityRate = parseNumber(row.authority_reported_rate);
+  if (authorityRate !== null && Number.isFinite(authorityRate) && Number.isFinite(computedRate) && Math.abs(authorityRate - computedRate) > 0.0001) {
+    error("T14_TABLE_SEMANTICS", "OFFICIAL_METRIC_AUTHORITY_RATE_MISMATCH", "official_election_metrics", id, "authority_reported_rate differs from computed_rate by more than rounding tolerance");
+  }
+}
+
+const catalogById = index.case_catalog;
+const catalogLayers = Object.freeze({
+  claim_coded_core: ["cases", "case_id"],
+  screening_register: ["candidates", "candidate_id"],
+  empirical_model_study: ["model_evaluations", "evaluation_id"]
+});
+for (const row of rows("case_catalog")) {
+  const id = rowId(row, "case_catalog");
+  const target = catalogLayers[clean(row.record_layer)];
+  const targetRow = target ? index[target[0]]?.get(clean(row.catalog_id)) : null;
+  if (target && !targetRow) {
+    error("T14_TABLE_SEMANTICS", "CATALOG_TARGET_UNKNOWN", "case_catalog", id, `${row.record_layer} does not resolve to ${target[0]}.${target[1]}`);
+  }
+  let expectedSourceCount = null;
+  if (clean(row.record_layer) === "claim_coded_core") {
+    expectedSourceCount = rows("case_sources").filter((item) => clean(item.case_id) === clean(row.catalog_id)).length;
+    if (targetRow && clean(row.record_type) !== clean(targetRow.record_type)) {
+      error("T14_TABLE_SEMANTICS", "CATALOG_RECORD_TYPE_MISMATCH", "case_catalog", id, "record_type differs from cases.csv");
+    }
+    if (targetRow && clean(row.manipulation_assessment) !== clean(targetRow.manipulation_assessment)) {
+      error("T14_TABLE_SEMANTICS", "CATALOG_MANIPULATION_MISMATCH", "case_catalog", id, "manipulation_assessment differs from cases.csv");
+    }
+  } else if (clean(row.record_layer) === "screening_register") {
+    expectedSourceCount = ids(targetRow?.source_urls).length;
+    if (clean(row.record_type) !== "candidate_lead") {
+      error("T14_TABLE_SEMANTICS", "CATALOG_CANDIDATE_TYPE_INVALID", "case_catalog", id, "screening_register must use record_type=candidate_lead");
+    }
+  } else if (clean(row.record_layer) === "empirical_model_study") {
+    expectedSourceCount = ids(targetRow?.source_id).length;
+    if (clean(row.record_type) !== "model_evaluation_or_experiment") {
+      error("T14_TABLE_SEMANTICS", "CATALOG_MODEL_TYPE_INVALID", "case_catalog", id, "empirical_model_study must use record_type=model_evaluation_or_experiment");
+    }
+  }
+  if (expectedSourceCount !== null && parseNumber(row.source_count_or_links) !== expectedSourceCount) {
+    error("T14_TABLE_SEMANTICS", "CATALOG_SOURCE_COUNT_MISMATCH", "case_catalog", id, `source_count_or_links differs from normalized/source links (${expectedSourceCount})`);
+  }
+}
+for (const [layer, [table, idField]] of Object.entries(catalogLayers)) {
+  for (const row of rows(table)) {
+    const id = clean(row[idField]);
+    const catalog = catalogById.get(id);
+    if (!catalog) {
+      error("T14_TABLE_SEMANTICS", "SOURCE_RECORD_MISSING_FROM_CATALOG", "case_catalog", id, `${table}.${idField} is absent from case_catalog.csv`);
+    } else if (clean(catalog.record_layer) !== layer) {
+      error("T14_TABLE_SEMANTICS", "CATALOG_LAYER_MISMATCH", "case_catalog", id, `Expected record_layer=${layer}; found ${clean(catalog.record_layer)}`);
+    }
+  }
+}
+
 function stableIssueOrder(a, b) {
   return (
     a.test.localeCompare(b.test) ||
@@ -1001,10 +1677,60 @@ blocking.sort(stableIssueOrder);
 advisory.sort(stableIssueOrder);
 
 const tableCounts = Object.fromEntries([...loaded.entries()].map(([name, table]) => [name, table.rows.length]));
+const integrityErrors = blocking.filter((item) => item.layer === "integrity");
+const integrityWarnings = advisory.filter((item) => item.layer === "integrity");
+const semanticErrors = blocking.filter((item) => item.layer === "semantic");
+const semanticWarnings = advisory.filter((item) => item.layer === "semantic");
+const semanticChecksByTable = Object.freeze({
+  cases: ["classification", "incident denominator", "case-family and election links", "pathway/actor/technology coverage"],
+  claims: ["documented enums", "case/source links", "normalized evidence and case-source reciprocity"],
+  sources: ["documented enums", "claim/event/case-source referential use"],
+  events: ["status/date chronology", "case-scoped claim links", "case-source reciprocity", "analytic join reciprocity"],
+  case_sources: ["unique case/source pair", "role and claim-type vocabulary", "claim/event reciprocity"],
+  watchlist: ["required monitoring fields", "status/cutoff chronology", "linked election date"],
+  candidates: ["sampling counts", "catalog membership and layer"],
+  official_elections: ["status chronology", "case/source links", "normalized join reciprocity"],
+  official_turnout: ["numeric ranges", "turnout and ballot arithmetic", "source/election chronology"],
+  official_results: ["coverage/status", "share/rank arithmetic", "turnout reconciliation"],
+  official_data_sources: ["family link", "status and retrieval chronology", "election-source use"],
+  official_election_metrics: ["numeric/rate ranges", "rate-component resolution", "rate recomputation", "source/election chronology"],
+  research_view: ["unique pathway projection", "case/pathway field parity", "complete pathway coverage"],
+  case_catalog: ["documented enums", "layer/record resolution", "incident denominator", "source-link counts"],
+  case_actors: ["documented attribution enum", "case-scoped claim links", "case and analytic coverage"],
+  technology_uses: ["provenance/version limitations", "case-scoped claim links", "AI-case and analytic coverage"],
+  content_items: ["case-scoped claim links", "analytic join reciprocity"],
+  pathways: ["documented transfer/assessment enums", "required proposition fields", "case/view/claim coverage"],
+  observations: ["numeric intervals and denominators", "causal-status requirements", "case/pathway/claim/source scope"],
+  model_evaluations: ["sample/design fields", "source link", "catalog membership and layer"],
+  claim_evidence: ["documented enums", "claim/source links", "legacy evidence reciprocity"],
+  analytic_record_claims: ["record-type resolution", "case-scoped claims", "legacy analytic-link reciprocity"],
+  case_elections: ["unique pair and relation", "case/election links", "legacy link reciprocity"],
+  election_sources: ["unique pair and role", "family consistency", "legacy and official-row reciprocity"],
+  sampling_frame: ["documented status", "counts/flags/dates", "region coverage"],
+  coverage_summary: ["unique region", "case/candidate/model counts"]
+});
 const report = {
-  auditor: "agency-transfer-election-cases-v0.3.0/audit-v03",
+  auditor: "agency-transfer-election-cases-v0.3.1/audit-v03",
   cutoff,
   status: blocking.length ? "fail" : "pass",
+  integrity: {
+    status: integrityErrors.length ? "fail" : "pass",
+    expected_table_count: EXPECTED_TABLES.length,
+    loaded_table_count: EXPECTED_TABLES.filter((name) => loaded.get(name)?.exists).length,
+    datapackage_resource_count: resourceByName.size,
+    declared_field_count: [...resourceByName.values()].reduce((sum, resource) => sum + (resource.schema?.fields?.length || 0), 0),
+    declared_foreign_key_count: [...resourceByName.values()].reduce((sum, resource) => sum + (resource.schema?.foreignKeys?.length || 0), 0),
+    error_count: integrityErrors.length,
+    warning_count: integrityWarnings.length
+  },
+  semantic_audit: {
+    status: semanticErrors.length ? "fail" : "pass",
+    audited_table_count: Object.keys(semanticChecksByTable).length,
+    audited_tables: Object.keys(semanticChecksByTable),
+    checks_by_table: semanticChecksByTable,
+    error_count: semanticErrors.length,
+    warning_count: semanticWarnings.length
+  },
   summary: {
     error_count: blocking.length,
     warning_count: advisory.length,

scripts/build-data.mjs

@@ -11,6 +11,7 @@ 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 releaseVersion = "0.3.1";
 const seed = JSON.parse(fs.readFileSync(seedPath, "utf8"));
 const officialElectoralData = JSON.parse(fs.readFileSync(officialElectoralDataPath, "utf8"));
 const extensions = JSON.parse(fs.readFileSync(extensionsPath, "utf8"));
@@ -221,17 +222,18 @@ const additionalOfficialSources = [
   ["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."]
+  ["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."],
+  ["off-nh-2024-dnc-status", "new-hampshire-biden-robocall-2024", "New Hampshire", "New Hampshire Department of Justice", "Unlawful Voter Suppression Cease and Desist Order", "https://www.doj.nh.gov/news-and-media/unlawful-voter-suppression-cease-and-desist-order", "institutional_primary_and_delegate_status", "final", "HTML official statement", "state", "landing page", "finalized election record", "official state statement", "2026-08-12", "Documents the institutional dispute and that the DNC did not award delegates from the 23 January state-run result; do not describe the election as legally nonexistent or infer a delegate allocation from its vote tally."]
 ].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" };
+  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 : ""),
+  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 || "",
@@ -293,6 +295,10 @@ for (const election of seed.official_elections) {
     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.";
   }
+  if (election.election_id === "elec-us-nh-dem-primary-2024") {
+    election.official_source_ids = appendPipe(appendPipe(election.official_source_ids, "off-nh-2024-primary-law"), "off-nh-2024-dnc-status");
+    election.notes = "The 23 January event was a state-run primary with a final state tally, but the DNC did not award delegates from that result. The tally therefore has delegate_effect=none_from_Jan23_results. The all-party checklist is not a valid Democratic-primary turnout denominator because undeclared voters may choose a party ballot and same-day registration or party changes occur.";
+  }
 }
 
 const mdTurnout = {
@@ -362,6 +368,11 @@ for (const row of seed.official_results) {
   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"; }
+  if (row.result_id === "result-md24r2-maia-sandu") { row.party_or_affiliation = ""; row.ballot_designating_entity = "PAS"; }
+  if (row.result_id === "result-md24r2-alexandr-stoianoglo") { row.party_or_affiliation = ""; row.ballot_designating_entity = "PSRM"; }
+  if (row.coverage_status === "complete_national_contest" && /Top-(?:three|five) extract|Top-five vote extract/i.test(row.notes || "")) {
+    row.notes = "Complete national contest field in this release.";
+  }
 }
 
 const extraResults = [];
@@ -408,6 +419,25 @@ seed.claims = seed.claims.map((claim) => {
   return { ...claim, coder_confidence_in_label: claim.confidence, claim_status: claimStatus, evidence_strength: evidenceStrength };
 });
 
+const claimTypesByCase = new Map();
+for (const claim of seed.claims) {
+  if (!claimTypesByCase.has(claim.case_id)) claimTypesByCase.set(claim.case_id, new Set());
+  claimTypesByCase.get(claim.case_id).add(claim.claim_type);
+}
+seed.case_sources = seed.case_sources.map((link) => {
+  const availableTypes = claimTypesByCase.get(link.case_id) || new Set();
+  const declaredTypes = String(link.supports_claim_types || "").split("|").filter(Boolean);
+  const supportedTypes = declaredTypes.filter((type) => availableTypes.has(type));
+  const removedTypes = declaredTypes.filter((type) => !availableTypes.has(type));
+  return {
+    ...link,
+    supports_claim_types: supportedTypes.join("|"),
+    notes: removedTypes.length
+      ? `${link.notes ? `${link.notes} ` : ""}Contextual source roles not represented by an atomic claim in this release were omitted from supports_claim_types: ${removedTypes.join("|")}.`
+      : link.notes
+  };
+});
+
 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);
@@ -426,6 +456,11 @@ seed.technology_uses = rowsFromArrays(extensions.technology_uses, schemas.techno
 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);
+for (const actor of seed.case_actors) {
+  if (actor.case_actor_id === "act-usca11-chan" && actor.attribution_status === "established") {
+    actor.attribution_status = "credibly_reported";
+  }
+}
 
 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]));
@@ -439,13 +474,15 @@ seed.observations = extensions.quantitative_observations.map((values) => {
 
 const sourceById = new Map(seed.sources.map((row) => [row.source_id, row]));
 seed.claim_evidence = [];
+const claimEvidenceLocators = extensions.claim_evidence_locators || {};
 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 });
+      const locatorKey = `${claim.claim_id}|${sourceId}|${relation}`;
+      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: claimEvidenceLocators[locatorKey] || "", extracted_at: claim.verified_at });
     }
   }
 }
@@ -495,8 +532,8 @@ 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" }))
+  ...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: "screening", 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: "", 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: `Evaluation window: ${row.evaluation_window}. ${row.causal_scope}`, last_checked: "2026-08-12" }))
 ];
 
 const frameNotes = {
@@ -697,7 +734,7 @@ const dataPackage = {
   profile: "tabular-data-package",
   name: "agency-transfer-election-cases",
   title: "AI, Elections and Agency Transfer Evidence Index",
-  version: "0.3.0",
+  version: releaseVersion,
   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]) => ({
@@ -713,6 +750,15 @@ const dataPackage = {
     }
   }))
 };
+const catalogResource = dataPackage.resources.find((resource) => resource.name === "case_catalog");
+const catalogDateField = catalogResource?.schema.fields.find((field) => field.name === "election_date");
+if (catalogDateField) {
+  catalogDateField.description = "ISO election date for core cases and screening leads; blank for empirical studies whose evaluation window is stored in model_evaluations.";
+}
+const observationResource = dataPackage.resources.find((resource) => resource.name === "observations");
+if (observationResource) {
+  observationResource.description = "Selected decision-relevant quantitative observations normalized from claims; absence of a row does not imply absence of all numeric text in the evidence corpus.";
+}
 const dataPackageText = JSON.stringify(dataPackage, null, 2) + "\n";
 fs.writeFileSync(path.join(outDir, "datapackage.json"), dataPackageText);
 fileHashes["datapackage.json"] = sha256(dataPackageText);

scripts/build-parquet.mjs

@@ -5,12 +5,20 @@ import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 
 const require = createRequire(import.meta.url);
-const parquet = require("parquetjs-lite");
+let parquet;
+try {
+  parquet = require("parquetjs-lite");
+} catch (error) {
+  throw new Error("Missing pinned dependency parquetjs-lite. Run npm install from the package root before rebuilding Parquet files.", { cause: error });
+}
 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 });
+for (const entry of await fs.readdir(outDir)) {
+  if (entry.endsWith(".parquet") || entry === "manifest.json") await fs.rm(path.join(outDir, entry));
+}
 
 function parseCsv(text) {
   const records = [];

scripts/build-workbook-v03.mjs

@@ -6,7 +6,7 @@ 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 outputDir = process.argv[2] || path.join(root, "outputs", "v0.3.1-workbook");
 const previewDir = path.join(outputDir, "previews");
 await fs.mkdir(previewDir, { recursive: true });
 
@@ -146,19 +146,20 @@ function addSectionTitle(sheet, range, text, fill = colors.charcoal) {
 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").values = [["AI, Elections and Agency Transfer — Evidence Index v0.3.1"]];
 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 = [
+overview.getRange("A5:B18").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],
+  ["Claim-evidence sources", data.sources.length],
+  ["Official data sources", data.official_data_sources.length],
   ["Screening leads", data.candidates.length],
   ["Empirical model studies", data.model_evaluations.length],
   ["Typed observations", data.observations.length],
@@ -168,7 +169,7 @@ overview.getRange("A5:B17").values = [
   ["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" } };
+overview.getRange("A6:B18").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 = [[
@@ -177,15 +178,15 @@ overview.getRange("D6:H14").values = [[
 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);
+addSectionTitle(overview, "A19:H19", "What changed in v0.3.1", 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."
+  "This maintenance release fixes machine-readable dates, complete-result notes, Moldova second-round designating entities and a drifting actor-attribution literal. It adds six bounded quantitative observations, explicit preparedness context, a documented single-coder limitation, a strict 26-table audit and pinned Parquet tooling. New Hampshire's state tally is now separated from its non-awarding delegate effect. Source locators and hashes remain blank where no verifiable archived snapshot exists."
 ]];
 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").values = [["Hard limit: this package is internally complete for its declared records and tables, not across all elections. Six regional sampling-frame warnings flag missing systematic negative searches. 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;
@@ -248,7 +249,7 @@ 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."],
+  ["Automated audit status", audit.status.toUpperCase(), "PASS", "Deterministic v0.3.1 audit across all 26 tables."],
   ["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."],
@@ -264,7 +265,7 @@ qa.getRange("A5:D16").values = [
 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").values = [["Warnings are not failed checks. They flag that prevalence inference is unsupported: 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);
@@ -308,7 +309,7 @@ const formulaErrors = await wb.inspect({ kind: "match", searchTerm: "#REF!|#DIV/
 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 outputPath = path.join(outputDir, "agency-transfer-election-evidence-index-v0.3.1.xlsx");
 const output = await SpreadsheetFile.exportXlsx(wb);
 await output.save(outputPath);
 process.stdout.write(`${outputPath}\n`);

scripts/validate-data.mjs

@@ -1,66 +1,204 @@
+#!/usr/bin/env node
+
+/**
+ * Read-only release validator.
+ *
+ * This wrapper keeps byte/hash integrity separate from the semantic audit. It
+ * writes one deterministic JSON report and exits non-zero when either layer
+ * fails. Semantic warnings remain non-blocking.
+ */
+
 import fs from "node:fs";
 import path from "node:path";
 import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
 const here = path.dirname(fileURLToPath(import.meta.url));
-const root = path.resolve(here, "..");
-const dataDir = path.join(root, "data");
-const expected = [
+const packageRoot = path.resolve(here, "..");
+const dataDir = path.resolve(process.argv[2] || path.join(packageRoot, "data"));
+const auditScript = path.join(here, "audit-v03.mjs");
+
+const EXPECTED_TABLES = Object.freeze([
   "cases", "claims", "sources", "events", "case_sources", "watchlist", "candidates",
-  "official_elections", "official_turnout", "official_results", "official_data_sources"
-];
-let failed = false;
+  "official_elections", "official_turnout", "official_results", "official_data_sources",
+  "official_election_metrics", "research_view", "case_catalog", "case_actors",
+  "technology_uses", "content_items", "pathways", "observations", "model_evaluations",
+  "claim_evidence", "analytic_record_claims", "case_elections", "election_sources",
+  "sampling_frame", "coverage_summary"
+]);
+const HASHED_DATA_FILES = Object.freeze([
+  ...EXPECTED_TABLES.map((name) => `${name}.csv`),
+  "schema.json",
+  "datapackage.json"
+]);
+
+const fileErrors = [];
+function fileError(code, file, message) {
+  fileErrors.push({ code, file: file || null, message });
+}
 
 function sha256(value) {
   return createHash("sha256").update(value).digest("hex");
 }
 
-for (const name of expected) {
-  const file = path.join(dataDir, name + ".csv");
-  if (!fs.existsSync(file)) {
-    process.stderr.write("missing: " + file + "\n");
-    failed = true;
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function pathInside(base, relativePath) {
+  if (typeof relativePath !== "string" || path.isAbsolute(relativePath)) return null;
+  const resolvedBase = path.resolve(base);
+  const resolved = path.resolve(resolvedBase, relativePath);
+  return resolved === resolvedBase || resolved.startsWith(`${resolvedBase}${path.sep}`) ? resolved : null;
+}
+
+function cleanOutput(value) {
+  return String(value || "").trim().replace(/\s+/g, " ").slice(0, 500);
+}
+
+if (!fs.existsSync(dataDir) || !fs.statSync(dataDir).isDirectory()) {
+  fileError("DATA_DIRECTORY_MISSING", dataDir, "Data directory is missing or is not a directory");
+}
+
+const actualCsvNames = fs.existsSync(dataDir)
+  ? fs.readdirSync(dataDir).filter((filename) => filename.endsWith(".csv")).sort()
+  : [];
+const expectedCsvNames = EXPECTED_TABLES.map((name) => `${name}.csv`).sort();
+for (const filename of expectedCsvNames) {
+  if (!actualCsvNames.includes(filename)) fileError("EXPECTED_CSV_MISSING", filename, "Expected release table is missing");
+}
+for (const filename of actualCsvNames) {
+  if (!expectedCsvNames.includes(filename)) fileError("UNEXPECTED_CSV", filename, "Unexpected CSV table is present");
+}
+
+for (const filename of expectedCsvNames) {
+  const filepath = path.join(dataDir, filename);
+  if (!fs.existsSync(filepath)) continue;
+  const contents = fs.readFileSync(filepath);
+  if (!contents.length || contents.at(-1) !== 0x0a) {
+    fileError("TRAILING_NEWLINE_MISSING", filename, "CSV must end with a newline");
+  }
+  if (contents.includes(0x00)) fileError("NUL_BYTE", filename, "CSV contains a NUL byte");
+}
+
+const statsPath = path.join(dataDir, "stats.json");
+let stats = null;
+if (!fs.existsSync(statsPath)) {
+  fileError("STATS_MISSING", "stats.json", "Integrity manifest is missing");
+} else {
+  try {
+    stats = JSON.parse(fs.readFileSync(statsPath, "utf8"));
+  } catch (caught) {
+    fileError("STATS_INVALID_JSON", "stats.json", `Invalid JSON: ${caught.message}`);
+  }
+}
+
+const inputHashes = stats?._integrity?.input_sha256;
+const fileHashes = stats?._integrity?.file_sha256;
+if (stats && !isPlainObject(inputHashes)) {
+  fileError("INPUT_HASHES_MISSING", "stats.json", "_integrity.input_sha256 must be an object");
+}
+if (stats && !isPlainObject(fileHashes)) {
+  fileError("FILE_HASHES_MISSING", "stats.json", "_integrity.file_sha256 must be an object");
+}
+if (isPlainObject(inputHashes) && !Object.keys(inputHashes).length) {
+  fileError("INPUT_HASHES_EMPTY", "stats.json", "At least one generated-input hash is required");
+}
+if (isPlainObject(fileHashes)) {
+  for (const filename of HASHED_DATA_FILES) {
+    if (!(filename in fileHashes)) fileError("DATA_HASH_ENTRY_MISSING", filename, "stats.json has no SHA-256 entry for this release file");
+  }
+}
+
+for (const [relativePath, expectedHash] of Object.entries(isPlainObject(inputHashes) ? inputHashes : {}).sort(([a], [b]) => a.localeCompare(b))) {
+  const filepath = pathInside(packageRoot, relativePath);
+  if (!filepath) {
+    fileError("INPUT_HASH_PATH_INVALID", relativePath, "Generated-input hash path must remain inside the package root");
     continue;
   }
-  const text = fs.readFileSync(file, "utf8");
-  if (!text.endsWith("\n")) {
-    process.stderr.write("missing trailing newline: " + file + "\n");
-    failed = true;
+  if (!/^[a-f0-9]{64}$/.test(String(expectedHash))) {
+    fileError("INPUT_HASH_INVALID", relativePath, "Expected input SHA-256 is not a lowercase 64-character digest");
+    continue;
   }
-  if (text.includes("\u0000")) {
-    process.stderr.write("NUL byte: " + file + "\n");
-    failed = true;
+  if (!fs.existsSync(filepath)) {
+    fileError("GENERATED_INPUT_MISSING", relativePath, "Hashed generated input is missing");
+  } else if (sha256(fs.readFileSync(filepath)) !== expectedHash) {
+    fileError("GENERATED_INPUT_HASH_MISMATCH", relativePath, "Generated input differs from stats.json");
   }
 }
 
-const statsPath = path.join(dataDir, "stats.json");
-if (!fs.existsSync(statsPath)) {
-  process.stderr.write("missing: " + statsPath + "\n");
-  failed = true;
+for (const [filename, expectedHash] of Object.entries(isPlainObject(fileHashes) ? fileHashes : {}).sort(([a], [b]) => a.localeCompare(b))) {
+  if (path.basename(filename) !== filename) {
+    fileError("DATA_HASH_PATH_INVALID", filename, "Generated-file hash keys must be plain filenames");
+    continue;
+  }
+  const filepath = path.join(dataDir, filename);
+  if (!/^[a-f0-9]{64}$/.test(String(expectedHash))) {
+    fileError("DATA_HASH_INVALID", filename, "Expected data SHA-256 is not a lowercase 64-character digest");
+    continue;
+  }
+  if (!fs.existsSync(filepath)) {
+    fileError("HASHED_DATA_FILE_MISSING", filename, "File listed in stats.json is missing");
+  } else if (sha256(fs.readFileSync(filepath)) !== expectedHash) {
+    fileError("DATA_HASH_MISMATCH", filename, "File differs from stats.json");
+  }
+}
+
+let auditReport = null;
+let auditFailure = null;
+if (!fs.existsSync(auditScript)) {
+  auditFailure = "Semantic audit script is missing";
 } else {
-  const stats = JSON.parse(fs.readFileSync(statsPath, "utf8"));
-  const integrity = stats._integrity;
-  if (!integrity?.input_sha256 || !integrity?.file_sha256) {
-    process.stderr.write("missing integrity hashes in data/stats.json\n");
-    failed = true;
+  const result = spawnSync(process.execPath, [auditScript, dataDir], {
+    encoding: "utf8",
+    maxBuffer: 16 * 1024 * 1024
+  });
+  if (result.error) {
+    auditFailure = `Semantic audit could not run: ${result.error.message}`;
   } else {
-    for (const [relativePath, expectedHash] of Object.entries(integrity.input_sha256)) {
-      const file = path.join(root, relativePath);
-      if (!fs.existsSync(file) || sha256(fs.readFileSync(file)) !== expectedHash) {
-        process.stderr.write("stale or missing generated input: " + relativePath + "\n");
-        failed = true;
-      }
+    try {
+      auditReport = JSON.parse(result.stdout);
+    } catch (caught) {
+      auditFailure = `Semantic audit did not return valid JSON: ${caught.message}`;
+    }
+    if (auditReport && ![0, 1].includes(result.status)) {
+      auditFailure = `Semantic audit terminated with unexpected exit status ${result.status}: ${cleanOutput(result.stderr)}`;
     }
-    for (const [filename, expectedHash] of Object.entries(integrity.file_sha256)) {
-      const file = path.join(dataDir, filename);
-      if (!fs.existsSync(file) || sha256(fs.readFileSync(file)) !== expectedHash) {
-        process.stderr.write("generated file hash mismatch: data/" + filename + "\n");
-        failed = true;
-      }
+    if (auditReport && ((auditReport.status === "pass") !== (result.status === 0))) {
+      auditFailure = `Semantic audit exit status ${result.status} disagrees with report status ${auditReport.status}`;
     }
   }
 }
 
-if (failed) process.exit(1);
-process.stdout.write("dataset files present, current, and structurally validated\n");
+fileErrors.sort((a, b) => a.code.localeCompare(b.code) || String(a.file).localeCompare(String(b.file)) || a.message.localeCompare(b.message));
+const auditIntegrity = auditReport?.integrity;
+const semanticAudit = auditReport?.semantic_audit;
+const integrityFailed = fileErrors.length > 0 || auditFailure !== null || auditIntegrity?.status !== "pass";
+const semanticFailed = auditFailure !== null || semanticAudit?.status !== "pass";
+const report = {
+  validator: "agency-transfer-election-cases-v0.3.1/validate-data",
+  status: integrityFailed || semanticFailed ? "fail" : "pass",
+  integrity: {
+    status: integrityFailed ? "fail" : "pass",
+    expected_table_count: EXPECTED_TABLES.length,
+    present_table_count: expectedCsvNames.filter((filename) => actualCsvNames.includes(filename)).length,
+    hashed_release_file_count: isPlainObject(fileHashes) ? Object.keys(fileHashes).length : 0,
+    hashed_input_count: isPlainObject(inputHashes) ? Object.keys(inputHashes).length : 0,
+    file_error_count: fileErrors.length,
+    contract_error_count: Number.isInteger(auditIntegrity?.error_count) ? auditIntegrity.error_count : null,
+    errors: fileErrors
+  },
+  semantic_audit: auditFailure ? {
+    status: "fail",
+    failure: auditFailure
+  } : {
+    status: semanticAudit.status,
+    audited_table_count: semanticAudit.audited_table_count,
+    error_count: semanticAudit.error_count,
+    warning_count: semanticAudit.warning_count
+  }
+};
+
+process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+if (report.status === "fail") process.exitCode = 1;