Jira progress: loading…

ZX-RRE-01

Rating Readiness Engine — KISMET Catalogue v1.0

00 Document control

Item	Value
Document ID	ZX-RRE-01 (proposed; pending registration in `config/system/acronyms.json`)
Version	1.0.0
Status	draft
Owner	CTO, Viroway Ltd
Governing contract	ZX-KISMET-01 — KISMET Contract Specification v1.0 (proposed)
Data-model schemas	`schemas/rating-readiness/zayaz.rre.*.v1.schema.json` (JSON Schema 2020-12)
KISMET contracts	`schemas/kismet/catalogue/rre/*.yaml` — every YAML block in this document is one of these files and validates against its KISMET schema
Golden vectors	`schemas/kismet/vectors/KISMET-KERNEL-DATA-PREDICATE_EVAL.1.0.0.json`, `…-DATA-REQUIREMENT_MATCH…`, `…-SCORE-COVERAGE…`, `…-DATA-SET_DIFF…`
Reference implementation	`schemas/kismet/reference/rre_kernels.py`, harness `run_vectors.py`, worked example `run_readiness_demo.py`
First target schema	EcoVadis Sustainability Rating — `schemas/rating-readiness/examples/RRE-SCHEMA-ECOVADIS.target-schema.yaml` (SEED)
Partner-facing brief	ECO-ECOVADIS-PF (proposed) — ZAYAZ Rating Readiness Brief — EcoVadis

This catalogue is the Rating Readiness Engine's declaration under KISMET. It defines the engine's kernels, resolvers, bindings, policies and composition, and the Pergamum Pulse content model those artifacts consume. It is the second KISMET consumer after Scope 3 and RIF, and the first whose kernels operate on structured records rather than numbers.

01 Purpose and scope

The Rating Readiness Engine (RRE) answers one question for one legal entity and one external rating or disclosure scheme: of what the scheme will ask this entity, how much can ZAYAZ already evidence, and from which records?

Its outputs are a criterion-by-criterion gap map, an evidence coverage measure, the set of criteria the ZAYAZ crosswalk cannot evidence yet, and the inputs from which the consuming engine assembles a questionnaire-ordered evidence pack. Its first target schema is EcoVadis; CDP, Sedex, IntegrityNext, the automotive SAQ, B Corp and ZAYAZ's own completeness levels are candidate schemas (§12). An independent rating body's methodology, should one be established, is simply another target schema.

In scope:

the Pergamum Pulse content model for a rating scheme and its crosswalk to ZAYAZ objects;
the predicate grammar through which a scheme's own rules become reference data;
the canonical evidence record ZAYAZ offers to any scheme;
four reusable kernels, two resolvers, five bindings, five policies and one composition;
conformance evidence: schemas, golden vectors, a reference implementation and a worked example.

Out of scope:

the EcoVadis questionnaire content itself beyond its public structure — criterion-level evidence specifications and activation beyond size bands require Viroway's rated-company access and are marked SEED in the target schema;
the evidence-pack artifact and the assisted-submission agent — consuming-engine concerns, registered separately (§14);
any prediction of a scheme's score, medal or badge; coverage is evidence completeness and the policies say so;
workflow consequences — notifying a partner, opening a task, flagging in Watchtower — which belong to the consuming authority, never to a KISMET policy (KMI-02, KMI-07).

02 Design principles

A scheme's rules are reference data, ZAYAZ's judgement is policy. Which criteria a scheme activates for a company of a given size and industry, and which documents it accepts, are facts about the scheme. They are transcribed into the target schema as predicates and resolved as snapshots. ZAYAZ's own view — what counts as covered or partial, when a client is ready, what ZAYAZ will refuse to offer at all — is governed KISMET policy. Neither lives in kernel code.
The crosswalk scopes evidence, the evidence type does not. A record enters a requirement only if a crosswalk entry offered it for that requirement (offered_for). An adopted climate policy is a valid policy_document; it is not evidence for the anti-corruption criterion. Without this rule a well-documented company would appear fully covered with three policies.
Undetermined is a first-class value. A profile attribute the registry has not captured, or an evidence attribute a record lacks, yields undetermined, never false. The gap map distinguishes "missing evidence" from "missing data about the evidence", and activation distinguishes "not in scope" from "scope unknown".
Coverage is completeness, not a score. The coverage kernel is generic weighted completeness; the credits it applies are a readiness convention; the bands a policy puts on it are working labels for a partner dashboard. None of it predicts what any scheme will award.
Gaps in ZAYAZ are reported, not hidden. Criteria activated for an entity that the crosswalk cannot evidence are an explicit output (manual evidence required) and feed the platform roadmap.
One kernel, many bindings (KMI-01). PREDICATE_EVAL serves both activation and evidence admissibility; COVERAGE and SET_DIFF are domain-neutral and expected to be reused by VSME completeness and elsewhere.
As-of pinning (KMI-05, KMI-06). A questionnaire is governed by the schema version in force when it was requested. Every execution pins the schema and crosswalk snapshots in its manifest; a quarterly methodology release is a new schema version, re-runs are new executions, and nothing recomputes history.

03 Data model — Pergamum Pulse content

Four schemas under schemas/rating-readiness/:

Schema	Holds	Consumed by
`zayaz.rre.predicate.v1`	Three-valued predicate grammar and `rule` records	`KISMET-KERNEL-DATA-PREDICATE_EVAL`; embedded in target schemas
`zayaz.rre.target-schema.v1`	One scheme version: themes, criteria, activation predicates, requirements per evidence layer, accepted evidence types and their predicates, weights, questionnaire references	`KISMET-RESOLVER-RRE-TARGET_SCHEMA`
`zayaz.rre.crosswalk.v1`	Requirement → ZAYAZ sources (selectors over policy templates, datapoints, certifications, courses, initiatives, documents, assessments); explicit `unmapped` entries	`KISMET-RESOLVER-RRE-CROSSWALK`; the consuming engine's record selection
`zayaz.rre.evidence-record.v1`	The canonical shape of any ZAYAZ object offered to a scheme: type, date, period, status, attributability, `offered_for`, computed `age_days`, source attributes	`KISMET-BINDING-RRE-EVIDENCE_ADMISSIBILITY`, `KISMET-KERNEL-DATA-REQUIREMENT_MATCH`

03.1 Predicate grammar

A predicate is a comparison { attr, op, value } or a combinator { all: [...] }, { any: [...] }, { not: ... }, { const: true|false }. Operators: eq neq gt gte lt lte between in not_in exists empty contains intersects matches. Ordered operators compare numbers with numbers and strings with strings (ISO 8601 dates compare lexically). A comparison whose attribute is absent from the context is undetermined; combinators follow Kleene logic (all with an undetermined operand is undetermined unless another operand is false; any is undetermined unless another is true). Type mismatches are undetermined by default and rejectable by guard.

03.2 Target schema

The target schema is a Pulse content object with effective dates and a self-declared completeness block so seed content is never mistaken for verified content. Excerpt of the EcoVadis seed (one criterion, one requirement shown):

schema_id: RRE-SCHEMA-ECOVADIS
scheme:
  code: ECOVADIS
  name: EcoVadis Sustainability Rating
  publisher: EcoVadis SAS
  kind: rating
  url: https://ecovadis.com/
version: 2026.10.0
effective:
  from: '2026-10-14'
  to: null
status: draft
completeness:
  activation_rules: seed
  evidence_specs: seed
  questionnaire_refs: seed
profile_attributes:
- attr: employee_count
  type: integer
  description: Headcount of the rated legal entity.
- attr: size_band
  type: enum
  values:
  - XS
  - S
  - M
  - L
  description: 'EcoVadis size category derived from employee_count: XS < 25, S 25–99, M 100–999, L ≥ 1,000
    (confirm bands once rated).'
- attr: nace_codes
  type: array
  description: NACE Rev. 2 codes of the entity's activities.
- …
evidence_types:
- policy_document
- endorsement
- procedure
- communication_attestation
- training_record
- certification
- improvement_initiative
- external_audit
- kpi_report
evidence_period:
  policy_max_age_days: 730
  kpi_max_age_days: 730
themes:
- theme_id: ECV-ENV
  name: Environment
  order: 1
- theme_id: ECV-LAB
  name: Labor & Human Rights
  order: 2
- theme_id: ECV-ETH
  name: Ethics
  order: 3
- theme_id: ECV-SUP
  name: Sustainable Procurement
  order: 4
criteria:
- criterion_id: ECV-LAB-01
  theme_id: ECV-LAB
  name: Employee health & safety
  order: 1
  activation:
    const: true
  requirements:
  - requirement_id: ECV-LAB-01-POL
    layer: policies
    name: Policies and endorsements
    evidence_specs:
    - spec_id: ECV-LAB-01-POL-S1
      evidence_type: policy_document
      min_count: 1
      predicate:
        all:
        - attr: status
          op: in
          value:
          - adopted
          - published
          - validated
          - completed
          - active
        - attr: attributable
          op: eq
          value: true
        - attr: age_days
          op: lte
          value: 730
    - spec_id: ECV-LAB-01-POL-S2
      evidence_type: endorsement
      min_count: 1
      predicate:
        all:
        - attr: status
          op: in
          value:
          - adopted
          - published
          - validated
          - completed
          - active
        - attr: attributable
          op: eq
          value: true
        - attr: age_days
          op: lte
          value: 730
    satisfaction:
      rule: min
      min_specs: 1
    weight: 1
    notes: SEED — a policy document is the expected evidence; an endorsement alone satisfies the seed
      rule only until the criterion-level help content is transcribed.
  - … (actions, results)
- … (21 criteria)

Field semantics worth stating:

criteria[].activation — the scheme's activation rule as a predicate over profile_attributes; { const: true } for universally activated criteria.
requirements[].layer — policies | actions | results, the three evidence layers; schemes without layers use a single layer.
evidence_specs[].predicate — the scheme's acceptance rule for that evidence type (status, age, attributability); its rule_id is the spec_id, which is how REQUIREMENT_MATCH joins predicate results to specs.
satisfaction — all, any or min with min_specs: the scheme's own notion of what satisfies the requirement. Used by the kernel to derive the structural state.
weight — readiness emphasis for coverage, default 1. Never a scheme scoring weight.
evidence_period — scheme-level governed values (e.g. maximum document age) referenced by evidence predicates. Reference data, not policy.

03.3 Crosswalk

crosswalk_id: RRE-XWALK-ECOVADIS
schema_ref:
  schema_id: RRE-SCHEMA-ECOVADIS
  version_range: '>=2026.10.0 <2027.0.0'
version: 1.0.0
status: draft
entries:
- requirement_id: ECV-LAB-01-POL
  status: mapped
  sources:
  - source_type: policy
    selector:
      policy_template_ids:
      - policy-social-health-safety
    produces_evidence_type: policy_document
    notes: Adopted policy in the client's own wording; adoption date → dated_at; adoption status → status.
- requirement_id: ECV-LAB-01-ACT
  status: mapped
  sources:
  - source_type: policy_attestation
    selector:
      policy_template_ids:
      - policy-social-health-safety
    produces_evidence_type: communication_attestation
    attribute_map:
      read_percentage: attributes.read_percentage
    notes: 'Per-policy export: version, distribution date, headcount, read percentage, dated sign-off
      log (counts only unless the client instructs otherwise).'
  - source_type: initiative
    selector:
      initiative_tags:
      - health_safety
    produces_evidence_type: improvement_initiative
  - source_type: certification
    selector:
      certification_codes:
      - ISO 45001
    produces_evidence_type: certification
    notes: Validated certifications only (lifecycle self_declared → validated → labeled).
  - source_type: certification
    selector:
      certification_codes:
      - ISO 45001
    produces_evidence_type: external_audit
    notes: The certification audit report, where stored, is offered separately as external_audit evidence
      (EcoVadis accepts certification audits as evidence of policy, action or reporting since Q1 2026).
  - source_type: training_record
    selector:
      course_ids:
      - ewa:TBD
    produces_evidence_type: training_record
    notes: SEED — EcoWorld Academy course IDs for H&S, anti-corruption and DEI training to be registered.
- requirement_id: ECV-LAB-01-RES
  status: mapped
  sources:
  - source_type: datapoint
    selector:
      datapoint_refs:
      - vsme:B9.accidents
      - vsme:B9.fatalities
      - vsme:B9.accident_rate
    produces_evidence_type: kpi_report
    attribute_map:
      kpi_unit: attributes.unit
    notes: Published Data Ladder datapoints; period_end → dated_at; publication status → status. VSME
      references until canonical field IDs are frozen.
- requirement_id: ECV-ETH-03-RES
  status: unmapped
  unmapped_reason: No ZAYAZ datapoint evidences this criterion's results layer yet; reported as 'manual
    evidence required' until the field exists.
  platform_gap_ref: 'REQ-NEW: data-breach datapoint'
- … (63 entries)

An entry's sources are selectors the consuming engine evaluates against the client tenant; each selected object becomes a canonical evidence record whose evidence_type is the entry's produces_evidence_type and whose offered_for contains the entry's requirement_id. An unmapped entry carries a reason and a platform_gap_ref; the resolver derives from the entries which criteria are fully evidenceable (mapped_criterion_ids).

Crosswalk admission checks every compatible target version. Each source's produces_evidence_type must be accepted by an evidence specification of that exact requirement, not merely appear in the scheme-wide catalogue. Each attribute_map key is a declared destination in evidence_record_attributes; its value is a field path in the source record. Declared nested destination paths are permitted. Unknown destinations and duplicate target attribute declarations fail validation. These checks establish structural compatibility; actual evidence must still satisfy predicates, scope and count requirements at runtime.

03.4 Canonical evidence record

Required: record_id entity_id source_type evidence_type offered_for title dated_at status attributable source_ref. Optional: period_start period_end age_days attributes document_hash. The consuming engine computes age_days = as_of − dated_at so scheme predicates can bound document age without any kernel knowing what a date is. status is the ZAYAZ lifecycle state (adopted, validated, published, completed, active, draft, superseded, lapsed, …); the policy admissibility floor requires a final status, a date and attributability regardless of scheme.

04 Kernels (KEC)

Four atomic kernels, all deterministic, none stochastic, none interpretive. Family codes DATA and SCORE are drawn from the proposed KISMET family vocabulary (ZX-KISMET-01 §12).

04.1 KISMET-KERNEL-DATA-PREDICATE_EVAL

contract_type: KEC
kernel_id: KISMET-KERNEL-DATA-PREDICATE_EVAL
version: 1.0.0
kind: atomic
family: DATA
title: Three-valued predicate evaluation
description: >-
  Evaluates a list of rules (zayaz.rre.predicate.v1) against a list of context objects and returns, for every
  rule × context pair, true, false or undetermined. A comparison whose attribute is absent from the context is
  undetermined, never false; combinators follow Kleene three-valued logic. Carries no interpretation: which rules
  are activation rules, evidence predicates or anything else is the binding's concern.
inputs:
  rules:
    type: array
    unit_class: any
    required: true
    description: "Array of { rule_id, predicate } conforming to zayaz.rre.predicate.v1 $defs/rule."
    constraints: { min_items: 1 }
  contexts:
    type: array
    unit_class: any
    required: true
    description: "Array of { context_id, attributes } where attributes is the object predicates are evaluated against."
    constraints: { min_items: 1 }
outputs:
  results:
    type: array
    unit_class: any
    description: "One entry per rule × context: { rule_id, context_id, value: true|false|undetermined, missing_attrs: [] }."
  true_rule_ids:
    type: array
    unit_class: any
    description: "rule_ids with value true in at least one context (for a single context: the rules that hold)."
  undetermined_rule_ids:
    type: array
    unit_class: any
    description: "rule_ids undetermined in at least one context."
  true_count:
    type: integer
    unit_class: count
  undetermined_count:
    type: integer
    unit_class: count
  rule_count:
    type: integer
    unit_class: count
guards:
  missing_input:      { options: [reject], default: reject }
  non_finite:         { options: [reject], default: reject }
  unknown_operator:   { options: [reject], default: reject }
  missing_attribute:  { options: [undetermined, reject], default: undetermined }
  type_mismatch:      { options: [undetermined, reject], default: undetermined }
  duplicate_rule_id:  { options: [reject], default: reject }
numerics:
  precision: float64
  deterministic: true
runtime:
  stochastic: false
  seed_required: false
  requirements: ["ECMA-262 regular expressions for op matches", "ISO 8601 dates compare lexically"]
conformance:
  golden_vectors: schemas/kismet/vectors/KISMET-KERNEL-DATA-PREDICATE_EVAL.1.0.0.json
  property_tests: [kleene_negation_involution, undetermined_absorbs_and, rule_order_independence]
governance:
  status: draft
  owner: architecture@viroway.com

04.2 KISMET-KERNEL-DATA-REQUIREMENT_MATCH

contract_type: KEC
kernel_id: KISMET-KERNEL-DATA-REQUIREMENT_MATCH
version: 1.0.0
kind: atomic
family: DATA
title: Requirement-to-evidence matching
description: >-
  For each requirement (a set of evidence specs with a satisfaction rule), selects the evidence records offered for
  that requirement (record.offered_for, assigned by the crosswalk — the crosswalk, not the evidence type, scopes
  evidence to a requirement) whose evidence_type matches a spec and whose scheme predicate evaluated true, then derives a structural state from
  the requirement's own satisfaction rule: satisfied, partial, unsatisfied, not_applicable (criterion not
  activated) or undetermined (a needed predicate result is undetermined and no determinate result satisfies the
  spec). The satisfaction rule is the scheme's; the labels ZAYAZ shows for each state belong to policy.
inputs:
  requirements:
    type: array
    unit_class: any
    required: true
    description: "Array of { requirement_id, criterion_id, evidence_specs: [{ spec_id, evidence_type, min_count }], satisfaction: { rule, min_specs } }."
    constraints: { min_items: 1 }
  activated_criteria:
    type: array
    unit_class: any
    required: true
    description: "criterion_ids in scope for this entity (from PREDICATE_EVAL true_rule_ids)."
  records:
    type: array
    unit_class: any
    required: true
    description: "Canonical evidence records { record_id, evidence_type, offered_for: [requirement_id], ... } (zayaz.rre.evidence-record.v1). May be empty."
  predicate_results:
    type: array
    unit_class: any
    required: true
    description: "PREDICATE_EVAL results with rule_id = spec_id and context_id = record_id. May be empty."
outputs:
  matches:
    type: array
    unit_class: any
    description: "Per requirement: { requirement_id, criterion_id, applicable, state, specs: [{ spec_id, evidence_type, matched_record_ids, undetermined_record_ids, satisfied }], specs_satisfied, specs_total }."
  states:
    type: array
    unit_class: any
    description: "Per requirement: { id: requirement_id, state } — the shape consumed by KISMET-KERNEL-SCORE-COVERAGE."
  requirement_count:
    type: integer
    unit_class: count
  applicable_count:
    type: integer
    unit_class: count
guards:
  missing_input:            { options: [reject], default: reject }
  non_finite:               { options: [reject], default: reject }
  duplicate_record_id:      { options: [dedupe, reject], default: dedupe }
  duplicate_requirement_id: { options: [reject], default: reject }
  duplicate_predicate_result: { options: [reject], default: reject }
  unknown_spec_ref:         { options: [ignore, reject], default: ignore }
  missing_scope:            { options: [reject], default: reject }
numerics:
  precision: integer
  deterministic: true
runtime:
  stochastic: false
  seed_required: false
conformance:
  golden_vectors: schemas/kismet/vectors/KISMET-KERNEL-DATA-REQUIREMENT_MATCH.1.0.0.json
  property_tests: [record_order_independence, monotone_in_evidence, inactive_criteria_not_applicable, unoffered_records_never_match]
governance:
  status: draft
  owner: architecture@viroway.com

State derivation, given s satisfied specs, u undetermined specs and need from the satisfaction rule (all → number of specs, any → 1, min → min_specs):

Condition	State
criterion not in `activated_criteria`	`not_applicable`
`s ≥ need`	`satisfied`
`s + u ≥ need`	`undetermined`
`s > 0`	`partial`
otherwise	`unsatisfied`

A spec is undetermined when its determinate matches fall short of min_count but determinate plus undetermined matches reach it. A record with no recorded predicate result for a spec counts as undetermined, never as matched.

04.3 KISMET-KERNEL-SCORE-COVERAGE

contract_type: KEC
kernel_id: KISMET-KERNEL-SCORE-COVERAGE
version: 1.0.0
kind: atomic
family: SCORE
title: Weighted completeness coverage
description: >-
  Computes weighted completeness over a list of items in named states: coverage = Σ weight(item) × credit(state)
  / Σ weight(item) over items whose state is not excluded. Generic — the same kernel serves rating readiness,
  VSME datapoint completeness and any checklist-style completeness. Which states exist, which are excluded and
  what credit they earn are inputs; what a coverage value means is policy.
inputs:
  items:
    type: array
    unit_class: any
    required: true
    description: "Array of { id, state }."
  weights:
    type: object
    unit_class: any
    required: false
    description: "Map id → weight (number ≥ 0). Missing ids weigh 1."
  credits:
    type: object
    unit_class: any
    required: true
    description: "Map state → credit in [0, 1]. A state mapped to null is excluded from both numerator and denominator (e.g. not_applicable)."
outputs:
  coverage:
    type: number
    unit_class: ratio
    description: "Weighted completeness in [0, 1]; null when the denominator is zero and zero_total_weight = return_null."
  weight_total:
    type: number
    unit_class: dimensionless
  weight_earned:
    type: number
    unit_class: dimensionless
  counts:
    type: object
    unit_class: any
    description: "Map state → number of items in that state (including excluded states)."
  item_count:
    type: integer
    unit_class: count
guards:
  missing_input:     { options: [reject], default: reject }
  non_finite:        { options: [reject], default: reject }
  zero_total_weight: { options: [return_null, reject], default: return_null }
  unknown_state:     { options: [reject], default: reject }
  negative_weight:   { options: [reject], default: reject }
  invalid_weight:    { options: [reject], default: reject }
  invalid_credit:    { options: [reject], default: reject }
  duplicate_item_id: { options: [reject], default: reject }
numerics:
  precision: float64
  deterministic: true
runtime:
  stochastic: false
  seed_required: false
conformance:
  golden_vectors: schemas/kismet/vectors/KISMET-KERNEL-SCORE-COVERAGE.1.0.0.json
  property_tests: [bounded_unit_interval, monotone_in_credit, weight_scale_invariance, item_order_independence]
governance:
  status: draft
  owner: architecture@viroway.com

04.4 KISMET-KERNEL-DATA-SET_DIFF

contract_type: KEC
kernel_id: KISMET-KERNEL-DATA-SET_DIFF
version: 1.0.0
kind: atomic
family: DATA
title: Set difference of identifier lists
description: >-
  Returns the identifiers present in left and absent from right (difference), those present in both
  (intersection) and the three counts. Order of the output arrays follows the order of first appearance in left.
  Generic identifier-set arithmetic; used by rating readiness to report activated criteria with no crosswalk entry.
inputs:
  left:
    type: array
    unit_class: any
    required: true
    description: "Array of identifier strings."
  right:
    type: array
    unit_class: any
    required: true
    description: "Array of identifier strings."
outputs:
  difference:
    type: array
    unit_class: any
  intersection:
    type: array
    unit_class: any
  left_count:
    type: integer
    unit_class: count
  right_count:
    type: integer
    unit_class: count
  difference_count:
    type: integer
    unit_class: count
guards:
  missing_input:    { options: [reject], default: reject }
  non_finite:       { options: [reject], default: reject }
  duplicate_items:  { options: [dedupe, reject], default: dedupe }
  non_string_item:  { options: [reject], default: reject }
numerics:
  precision: integer
  deterministic: true
runtime:
  stochastic: false
  seed_required: false
conformance:
  golden_vectors: schemas/kismet/vectors/KISMET-KERNEL-DATA-SET_DIFF.1.0.0.json
  property_tests: [difference_disjoint_from_right, intersection_subset_of_both, counts_consistent]
governance:
  status: draft
  owner: architecture@viroway.com

05 Resolvers (KRC)

Both resolvers return one atomic snapshot (atomic_cohort: true), so activation rules, requirements and weights can never come from different schema versions within one execution (KMI-03).

05.1 KISMET-RESOLVER-RRE-TARGET_SCHEMA

contract_type: KRC
resolver_id: KISMET-RESOLVER-RRE-TARGET_SCHEMA
version: 1.0.0
owner: RRE
title: Rating target schema in force at a date
description: >-
  Resolves one rating scheme's target schema (zayaz.rre.target-schema.v1, held in Pergamum Pulse) to the version
  that governs an execution: a pinned version when the questionnaire has one, otherwise the version effective at
  as_of. Returns the schema's parts as one atomic snapshot so activation rules, requirements and weights can never
  come from different versions.
inputs:
  scheme_code:    { required: true,  format: "RRE target schema scheme.code, e.g. ECOVADIS" }
  as_of:          { required: true,  format: date }
  pinned_version: { required: false, format: semver — the version recorded when the questionnaire was requested }
fallback_chain:
  - { level: 1, match: [scheme_code, pinned_version],     description: "Exact version pinned to the client's questionnaire." }
  - { level: 2, match: [scheme_code, effective_at_as_of], description: "Version whose effective window contains as_of." }
  - { level: 3, match: [scheme_code, latest_published],   description: "Latest published version; only reachable when as_of precedes every effective window. Admissibility is a policy decision." }
atomic_cohort: true
output:
  statistics:
    schema: object
    activation_rules: series
    evidence_specs: series
    requirements: series
    weights: object
    criterion_ids: series
    questionnaire_order: series
  unit: string
  cohort_id: string
  observation_count: integer
  fallback_level: integer
  snapshot_ref: string
  snapshot_hash: string
  source_refs: array
  quality_metadata: object
failure:
  no_eligible_cohort: insufficient_evidence
  snapshot_unavailable: unresolved
governance:
  status: draft
  owner: architecture@viroway.com
  data_sources: [Pergamum Pulse — rating target schemas (zayaz.rre.target-schema.v1)]

statistics carries the schema decomposed into the shapes the kernels consume: activation_rules (rules with rule_id = criterion_id), evidence_specs (rules with rule_id = spec_id), requirements, weights, criterion_ids, questionnaire_order. cohort_id is <scheme_code>/<version>; observation_count is the number of requirements.

05.2 KISMET-RESOLVER-RRE-CROSSWALK

contract_type: KRC
resolver_id: KISMET-RESOLVER-RRE-CROSSWALK
version: 1.0.0
owner: RRE
title: Crosswalk compatible with a target schema version
description: >-
  Resolves the crosswalk (zayaz.rre.crosswalk.v1) whose schema_ref range contains the resolved target schema
  version, preferring the latest published crosswalk. Derives, from the entries, the set of criteria that have at
  least one usable ZAYAZ source for every requirement (mapped_criterion_ids) and the requirements recorded as
  unmapped, so the engine can report gaps in ZAYAZ coverage separately from gaps in the client's evidence.
inputs:
  scheme_code:    { required: true, format: "RRE target schema scheme.code" }
  schema_version: { required: true, format: semver — the version resolved by KISMET-RESOLVER-RRE-TARGET_SCHEMA }
  as_of:          { required: true, format: date }
fallback_chain:
  - { level: 1, match: [scheme_code, schema_version, latest_published], description: "Latest published crosswalk whose range contains schema_version." }
  - { level: 2, match: [scheme_code, schema_version, latest_review],    description: "Latest crosswalk in review whose range contains schema_version; for pre-release readiness checks only." }
atomic_cohort: true
output:
  statistics:
    entries: series
    mapped_criterion_ids: series
    partial_requirement_ids: series
    unmapped_requirement_ids: series
  unit: string
  cohort_id: string
  observation_count: integer
  fallback_level: integer
  snapshot_ref: string
  snapshot_hash: string
  source_refs: array
  quality_metadata: object
failure:
  no_eligible_cohort: insufficient_evidence
  snapshot_unavailable: unresolved
governance:
  status: draft
  owner: architecture@viroway.com
  data_sources: [Pergamum Pulse — rating crosswalks (zayaz.rre.crosswalk.v1)]

Derivation rule for mapped_criterion_ids: a criterion is mapped when every one of its requirements has a crosswalk entry whose status is mapped or partial. partial_requirement_ids and unmapped_requirement_ids are exposed so the gap map can label rows "manual evidence required" where ZAYAZ itself is the gap.

06 Bindings (KBC)

Binding	Kernel	Signal inputs	Resolver slots	Policy slot
`KISMET-BINDING-RRE-CRITERIA_ACTIVATION`	`DATA-PREDICATE_EVAL`	`sssr:entity.rating_profile`	`target_schema`	boolean
`KISMET-BINDING-RRE-EVIDENCE_ADMISSIBILITY`	`DATA-PREDICATE_EVAL`	`sssr:entity.rating_evidence_records`	`target_schema`	boolean
`KISMET-BINDING-RRE-REQUIREMENT_MATCH`	`DATA-REQUIREMENT_MATCH`	`sssr:entity.rating_evidence_records` + composition outputs	`target_schema`	band
`KISMET-BINDING-RRE-COVERAGE`	`SCORE-COVERAGE`	composition output + literal credit map	`target_schema`	band
`KISMET-BINDING-RRE-UNMAPPED_CRITERIA`	`DATA-SET_DIFF`	composition output	`crosswalk`	boolean

The two PREDICATE_EVAL bindings are the catalogue's demonstration of KMI-01: one kernel, two business functions (activation, evidence admissibility), zero duplicated code.

06.1 KISMET-BINDING-RRE-REQUIREMENT_MATCH

contract_type: KBC
binding_id: KISMET-BINDING-RRE-REQUIREMENT_MATCH
version: 1.0.0
kernel:
  id: KISMET-KERNEL-DATA-REQUIREMENT_MATCH
  version: ">=1.0.0 <2.0.0"
owner: RRE
title: Match evidence to every requirement of the activated criteria
description: >-
  Produces the gap map rows: for each requirement, the evidence that satisfies each spec and the structural state
  derived from the scheme's satisfaction rule. Consumes the activation and admissibility results from the
  composition and the evidence records from the signal.
aliases: [gap map, criterion coverage table]
inputs:
  requirements:
    source: resolver
    slot: target_schema
    field: statistics.requirements
  activated_criteria:
    source: composition
    node: activation
    output: true_rule_ids
  records:
    source: signal
    ref: sssr:entity.rating_evidence_records
  predicate_results:
    source: composition
    node: admissibility
    output: results
resolver_slots:
  target_schema:
    resolver_id: KISMET-RESOLVER-RRE-TARGET_SCHEMA
    version: ">=1.0.0 <2.0.0"
    dimensions: [scheme_code, as_of, pinned_version]
guards:
  duplicate_record_id: dedupe
  duplicate_predicate_result: reject
  unknown_spec_ref: ignore
policy_slot:
  required: true
  verdict_type: band
method_ref: null
governance:
  status: draft
  owner: architecture@viroway.com

06.2 KISMET-BINDING-RRE-COVERAGE

contract_type: KBC
binding_id: KISMET-BINDING-RRE-COVERAGE
version: 1.0.0
kernel:
  id: KISMET-KERNEL-SCORE-COVERAGE
  version: ">=1.0.0 <2.0.0"
owner: RRE
title: Evidence coverage over activated requirements
description: >-
  Weighted completeness of the gap map. Credits are a readiness convention (partial evidence earns half credit)
  and not_applicable requirements are excluded from the denominator; neither is a prediction of any scheme's score.
  Weights come from the target schema and default to 1.
aliases: [readiness coverage, evidence completeness]
inputs:
  items:
    source: composition
    node: match
    output: states
  weights:
    source: resolver
    slot: target_schema
    field: statistics.weights
  credits:
    source: literal
    value: { satisfied: 1.0, partial: 0.5, unsatisfied: 0.0, undetermined: 0.0, not_applicable: null }
resolver_slots:
  target_schema:
    resolver_id: KISMET-RESOLVER-RRE-TARGET_SCHEMA
    version: ">=1.0.0 <2.0.0"
    dimensions: [scheme_code, as_of, pinned_version]
guards:
  zero_total_weight: return_null
policy_slot:
  required: true
  verdict_type: band
method_ref: null
governance:
  status: draft
  owner: architecture@viroway.com

The credit map is numerical configuration, permitted on a binding; it carries no threshold, direction or severity. Changing partial credit from 0.5 is a binding version, visible in every manifest.

07 Policies (KPC)

Policy	Applies to	Verdict	Interprets
`KISMET-POLICY-RRE-ACTIVATION_DETERMINACY`	CRITERIA_ACTIVATION	boolean	Is the registry profile complete enough to know the scope?
`KISMET-POLICY-RRE-EVIDENCE_ADMISSIBILITY`	EVIDENCE_ADMISSIBILITY	boolean	ZAYAZ's floor: dated, final status, attributable
`KISMET-POLICY-RRE-REQUIREMENT_STATUS`	REQUIREMENT_MATCH	band	Covered / Partial / Missing labels per row
`KISMET-POLICY-RRE-READINESS_BANDS`	COVERAGE	band	ready / in progress / not ready, governed thresholds
`KISMET-POLICY-RRE-UNMAPPED_CRITERIA`	UNMAPPED_CRITERIA	boolean	Platform-gap warning

07.1 KISMET-POLICY-RRE-REQUIREMENT_STATUS

contract_type: KPC
$schema: https://schemas.zayaz.io/kismet/zayaz.kismet.policy.v2.schema.json
policy_id: KISMET-POLICY-RRE-REQUIREMENT_STATUS
version: 2.0.0
owner: RRE
title: Gap-map status labels for requirement states
description: >-
  Maps the structural state of each requirement to the label the gap map shows: band 0 "Covered" (satisfied or
  not_applicable), band 1 "Partial" (some but not all required specs satisfied), band 2 "Missing" (unsatisfied or
  undetermined). The band table is applied row-wise by the consuming engine; the execution verdict carries the
  worst band present. Partial never counts as covered.
verdict_type: band
applies_to:
  binding_ids: [KISMET-BINDING-RRE-REQUIREMENT_MATCH]
  scope: { scheme_codes: "*" }
effective: { from: "2026-11-01", to: null }
interpretation:
  variables: { state: string }
  direction: band
  bands:
    - { severity: info, label: Covered, when: "state in ['satisfied', 'not_applicable']" }
    - { severity: warn, label: Partial, when: "state == 'partial'" }
    - { severity: fail, label: Missing, when: "state in ['unsatisfied', 'undetermined']" }
admissibility:
  max_resolver_fallback_level: 2
verdict:
  fields: [severity, admissible, rationale, band_index]
authority_ref: RRE
calibration:
  auto_apply: false
governance:
  status: draft
  owner: architecture@viroway.com

Row-wise application. REQUIREMENT_MATCH returns one state per requirement. The band table is applied by the consuming engine to every row to produce the row's label, and the execution verdict carries the worst band present with band_index set accordingly. KISMET v1 defines a verdict per execution; applying a band table element-wise to an array result is a reading of KPC that this catalogue adopts and flags for confirmation in ZX-KISMET-01 (§14, item 9).

07.2 KISMET-POLICY-RRE-READINESS_BANDS

contract_type: KPC
$schema: https://schemas.zayaz.io/kismet/zayaz.kismet.policy.v2.schema.json
policy_id: KISMET-POLICY-RRE-READINESS_BANDS
version: 2.0.0
owner: RRE
title: Readiness bands over evidence coverage
description: >-
  Interprets coverage for the partner dashboard: "ready" means the client's evidence is complete relative to the
  activated criteria, "in progress" and "not ready" otherwise. The thresholds are governed working values and may
  be scoped per scheme. Coverage is evidence completeness; the verdict says nothing about the score, medal or
  badge a scheme will award.
verdict_type: band
applies_to:
  binding_ids: [KISMET-BINDING-RRE-COVERAGE]
  scope: { scheme_codes: "*" }
effective: { from: "2026-11-01", to: null }
interpretation:
  variables: { coverage: number }
  direction: band
  parameters: { ready_at: 0.9, in_progress_at: 0.5 }
  bands:
    - { severity: info, label: ready, when: "coverage >= ready_at" }
    - { severity: warn, label: in progress, when: "in_progress_at <= coverage < ready_at" }
    - { severity: fail, label: not ready, when: "coverage < in_progress_at" }
admissibility:
  max_resolver_fallback_level: 2
verdict:
  fields: [severity, admissible, rationale, band_index, score]
  score_source: coverage
authority_ref: RRE
calibration:
  proposals_allowed_from: [rre_partner_feedback_review]
  auto_apply: false
governance:
  status: draft
  owner: architecture@viroway.com

ready_at and in_progress_at are governed working values. Partner feedback may propose new values through calibration.proposals_allowed_from; nothing applies automatically (KMI-07).

The worked demo loads both KPCs above and the coverage KBC once per run, validates them, and reports their exact versions and SHA-256 hashes. Labels and thresholds come from the KPCs; credits and coverage guards come from the KBC. Raw coverage is interpreted before rounding for display. Row verdicts retain severity, band index, rationale and admissibility; the aggregate requirement verdict carries the worst severity. “Manual evidence required” remains separate platform-gap guidance, with the governed policy label retained alongside it. Inadmissible evidence suppresses the displayed readiness label while retaining the calculated verdict. Null coverage yields no readiness verdict or label.

This is a draft, offline calculation fixture, not a complete admitted composition execution: the other three KPCs, live crosswalk selection, approval and ZAR/ALTD custody remain outside this demo. Reported contract hashes are not a replay-custody claim.

08 Composition (KCC)

contract_type: KCC
composition_id: KISMET-COMPOSITION-RRE-RATING_READINESS
version: 1.0.0
owner: RRE
title: Rating readiness — gap map, coverage and platform gaps for one entity and one scheme
description: >-
  The readiness projection: target schema and crosswalk resolved as pinned snapshots, criteria activated from the
  entity profile, scheme evidence predicates evaluated over the entity's evidence records, requirements matched,
  coverage computed and unmapped criteria reported. Signal inputs (profile, evidence records) and the credit map
  enter through the node bindings KISMET-BINDING-RRE-*; edges carry only kernel and resolver outputs. The evidence
  pack is assembled by the consuming engine from the matches output and is not a KISMET node.
nodes:
  - { id: target_schema, kind: resolver, ref: KISMET-RESOLVER-RRE-TARGET_SCHEMA,    version: ">=1.0.0 <2.0.0" }
  - { id: crosswalk,     kind: resolver, ref: KISMET-RESOLVER-RRE-CROSSWALK,        version: ">=1.0.0 <2.0.0" }
  - { id: activation,    kind: kernel,   ref: KISMET-KERNEL-DATA-PREDICATE_EVAL,    version: ">=1.0.0 <2.0.0" }
  - { id: admissibility, kind: kernel,   ref: KISMET-KERNEL-DATA-PREDICATE_EVAL,    version: ">=1.0.0 <2.0.0" }
  - { id: match,         kind: kernel,   ref: KISMET-KERNEL-DATA-REQUIREMENT_MATCH, version: ">=1.0.0 <2.0.0" }
  - { id: coverage,      kind: kernel,   ref: KISMET-KERNEL-SCORE-COVERAGE,         version: ">=1.0.0 <2.0.0" }
  - { id: unmapped,      kind: kernel,   ref: KISMET-KERNEL-DATA-SET_DIFF,          version: ">=1.0.0 <2.0.0" }
edges:
  - { from: target_schema.output.activation_rules,     to: activation.input.rules }
  - { from: target_schema.output.evidence_specs,       to: admissibility.input.rules }
  - { from: target_schema.output.requirements,         to: match.input.requirements }
  - { from: activation.output.true_rule_ids,           to: match.input.activated_criteria }
  - { from: admissibility.output.results,              to: match.input.predicate_results }
  - { from: match.output.states,                       to: coverage.input.items }
  - { from: target_schema.output.weights,              to: coverage.input.weights }
  - { from: activation.output.true_rule_ids,           to: unmapped.input.left }
  - { from: crosswalk.output.mapped_criterion_ids,     to: unmapped.input.right }
error_propagation:
  on_node_failure: halt
  on_inadmissible_evidence: propagate_verdict
outputs:
  - { name: activated_criteria,      from: activation.output.true_rule_ids }
  - { name: undetermined_activation, from: activation.output.undetermined_rule_ids }
  - { name: gap_map,                 from: match.output.matches }
  - { name: requirement_states,      from: match.output.states }
  - { name: coverage,                from: coverage.output.coverage }
  - { name: state_counts,            from: coverage.output.counts }
  - { name: unmapped_criteria,       from: unmapped.output.difference }
governance:
  status: draft
  owner: architecture@viroway.com

Data flow:

target_schema ──activation_rules──▶ activation ──true_rule_ids──┬──▶ match ──states──▶ coverage ──▶ coverage
      │                                                        │      ▲                    weights ◀── target_schema
      ├──evidence_specs────────────▶ admissibility ──results───┼──────┘
      ├──requirements──────────────────────────────────────────┘
      └──weights ─────────────────────────────────────────────────────────────────────────────▶ coverage
crosswalk ──mapped_criterion_ids──▶ unmapped ◀──true_rule_ids── activation        ──▶ unmapped_criteria

Signal inputs — the entity's rating profile and its evidence records — and the credit map enter through the node bindings, not through edges; KCC v1 has no node-level binding reference, so the association is by convention (activation ↔ CRITERIA_ACTIVATION, admissibility ↔ EVIDENCE_ADMISSIBILITY, match ↔ REQUIREMENT_MATCH, coverage ↔ COVERAGE, unmapped ↔ UNMAPPED_CRITERIA) and flagged in §14.

09 Execution, evidence and the consuming engine

A KISMET v1 manifest is scoped to one kernel execution under one binding, so a composition run yields one manifest per kernel node. The example at schemas/kismet/catalogue/rre/execution-manifest.rre-example.yaml is the match node's: it pins the target-schema snapshot (pulse/rating-schemas/RRE-SCHEMA-ECOVADIS/2026.10.0), the resolved composition graph with exact versions, the input and output payload references and hashes, the resolved guards (binding overrides over kernel defaults), the implementation build reference and hash, the reproducibility declaration (deterministic, tolerance 0 for an integer-precision kernel) and the verdict. The crosswalk snapshot is pinned in the unmapped node's manifest, whose binding declares that resolver slot. evidence_state stays pending_anchor until an ALTD receipt exists; anchored requires lineage.altd_ref.

The consuming engine (the RRE readiness engine in the Reports & Insights hub; CMI pending) performs the duties that are not kernels:

derive rating_profile attributes from the registry (size band from headcount, high-risk flag from the country sensitivity table, product flags);
evaluate crosswalk selectors against the tenant and emit canonical evidence records with evidence_type, offered_for and age_days;
execute the composition, write the manifest to ZAR lineage;
apply the REQUIREMENT_STATUS band table row-wise, and label rows "manual evidence required" where the crosswalk entry is unmapped and the row is not satisfied;
assemble the evidence pack from gap_map matches in questionnaire_order (ARTIF registration pending, §14);
hand verdict changes to Watchtower and the partner dashboard — consequences, outside KISMET.

10 Worked example

run_readiness_demo.py runs the composition on the EcoVadis seed for a synthetic 40-employee Norwegian manufacturer holding three adopted policies with read attestations, one outdated and one draft policy, ISO 14001 with its audit report, one LED initiative and four published datapoints. Output (abridged):

activated criteria: 19/21   undetermined: []
coverage: 0.211  → not ready   counts: satisfied 11, partial 2, unsatisfied 44, not_applicable 6
unmapped criteria (platform gaps): ECV-ENV-06, ECV-ENV-07, ECV-ENV-08, ECV-LAB-05, ECV-ETH-02, ECV-ETH-03

ECV-ENV-01-POL  Energy consumption & GHGs   satisfied    Covered                   pol-climate
ECV-ENV-01-ACT  Energy consumption & GHGs   satisfied    Covered                   att-climate, audit-14001, cert-14001, init-led
ECV-ENV-01-RES  Energy consumption & GHGs   satisfied    Covered                   kpi-energy, kpi-ghg1
ECV-ENV-02-POL  Water                       unsatisfied  Missing                   (draft policy not admissible)
ECV-ENV-02-ACT  Water                       satisfied    Covered                   audit-14001, cert-14001
ECV-ENV-05-POL  Materials, chemicals & waste unsatisfied Missing                   (policy older than the seed age rule)
ECV-ENV-06-RES  Product use                 unsatisfied  Manual evidence required  (crosswalk unmapped)
ECV-LAB-01-ACT  Employee health & safety    partial      Partial                   att-hs (1 of 2 action evidences)

Two things the example shows that a specification cannot: the ISO 14001 certificate counts toward every environment criterion's actions layer because the crosswalk offers it there and nowhere else; and ENV-09 is correctly out of scope because the profile says the company provides no environmental services — not because evidence is missing.

11 Versioning and methodology currency

Event	Pulse action	Engine behaviour
Scheme publishes a methodology release	New target-schema version with `effective.from`; previous version gets `effective.to`	Executions after the date resolve the new version at fallback level 2; questionnaires requested before it stay pinned (level 1)
ZAYAZ adds a field that evidences a criterion	New crosswalk version; `unmapped` → `mapped`	Next execution reports the criterion as evidenceable; prior manifests unchanged (KMI-07)
Policy thresholds change	New KPC version via policy governance	Subsequent executions only
Credit map changes	New binding version	Subsequent executions only
Watchtower observes a new schema version	—	Re-runs affected entities, compares verdicts to the previous manifest, flags changes to the partner

Target-schema versions use the scheme's release cadence in semver form (2026.10.0 for the EcoVadis release effective 2026-10-14). Crosswalk schema_ref.version_range follows KISMET range syntax.

12 Scheme shortlist — what each candidate adds to the model

The engine is scheme-agnostic by contract; the shortlist below is what would exercise it, with the structural feature each scheme introduces. A decision on which three to five follow EcoVadis is requested.

Scheme	Kind	What it adds to the model	Model impact
EcoVadis	rating	Adaptive activation, three evidence layers, document-based evidence	Baseline (this catalogue)
CDP (corporate / SME questionnaire)	disclosure	Sector modules; graded answers (disclosure → leadership) rather than binary evidence; numeric targets	Evidence specs with graded `attributes`; a `level` dimension on predicates — no new kernel
Sedex SMETA / SAQ	self-assessment + audit	Site-level scope: criteria activate per site, not per entity	Profile contexts become `(entity, site)` pairs — `PREDICATE_EVAL` already takes many contexts; crosswalk selectors need a site dimension
IntegrityNext	self-assessment	Topic-based questionnaires with certificate uploads; continuous news screening	Thin: mostly certification and policy evidence types
Drive Sustainability SAQ (automotive)	self-assessment	Sector-specific obligations, supplier cascade	Reuses the Supplier Programme's E-C-O relationships; crosswalk to supplier assessments
B Corp (B Impact Assessment)	certification	Points-based, size and sector tracks, verification stage	Weights carry real meaning here; `COVERAGE` credits need a `points` variant or a second binding
Independent ECO-Rating body (if established)	rating	A methodology ZAYAZ does not own	Target schema authored by the body, resolved like any other; proves the separation (§01)
ZAYAZ completeness levels	internal	VSME Basic completeness as a target schema	Dogfoods `COVERAGE` and `SET_DIFF`; one crosswalk is the identity mapping

13 Conformance

Check	Command	Expected
Data-model schemas are valid JSON Schema	`python3 -c "import json,jsonschema,glob; [jsonschema.Draft202012Validator.check_schema(json.load(open(f))) for f in glob.glob('schemas/rating-readiness/*.json')]"`	no output
EcoVadis seed validates (schema + referential checks)	`python3 schemas/rating-readiness/validate.py`	`PASS` ×2
KISMET contracts validate against ZX-KISMET-01 schemas and KPC grammar	`python3 schemas/kismet/reference/validate_contracts.py`	`ALL OK`
Policy domain, boundary, rejection and recalibration regressions	`python3 -m pytest schemas/kismet/reference/test_policy_evaluator.py -q`	all pass
Reference kernels reproduce their golden vectors	`python3 schemas/kismet/reference/run_vectors.py`	`ALL OK`; the separate z-score implementation is checked by `conformance_harness.py`
Any other implementation	`python3 schemas/kismet/reference/run_vectors.py <module>`	`ALL OK`
Worked example	`python3 schemas/kismet/reference/run_readiness_demo.py`	coverage 0.211, 6 unmapped criteria

14 Open items requiring registration or decision

Document ID ZX-RRE-01 — registration in config/system/acronyms.json.
Owner code RRE in the KISMET identifier grammar (KISMET-<KIND>-RRE-<NAME>), alongside RIF, S3, CORE.
Family codes DATA and SCORE — confirm in the KISMET family vocabulary registry (ZX-KISMET-01 §12).
Content identifier forms RRE-SCHEMA-<CODE> and RRE-XWALK-<CODE> for Pulse objects — registry decision; both are marked proposed in the schemas.
Artifacts — the gap map and the evidence pack are persistent business artifacts: propose ARTIF-RATING-GAP-MAP and ARTIF-RATING-EVIDENCE-PACK with runtime identifiers, CSI transport contracts, producing engine and owning specification per the artifact-naming rule. Not created here.
Consuming engine CMI for the RRE readiness engine (used as executed_by in manifests; placeholder in the example).
Canonical datapoint identifiers — the crosswalk references VSME disclosures (vsme:B3.ghg_scope1) and one ZAYAZ-native metric (zayaz:supply_chain.suppliers_assessed_share) pending the field-registry freeze.
EcoWorld Academy course IDs for H&S, anti-corruption and DEI training (ewa:TBD in the crosswalk).
KISMET amendments proposed from this consumer: (a) node-level binding references in KCC so signal inputs are declared, not conventional; (b) element-wise band application for array results, or a vector verdict type; (c) confirmation of the sssr: signal reference syntax used in bindings; (d) a composition-level manifest, or a per-node manifest list, so every resolver snapshot a composition consumed is pinned in one evidence record rather than across node manifests.
Full consuming-adapter conformance: the shared evaluator now supports typed policy variables, optional cohort admissibility fields and extended verdict fields. These policies explicitly select KPC v2 and use artifact version 2.0.0; original v1 policies remain schema-valid but require explicit migration before typed execution (ZX-KISMET-01 §06). The readiness verdict derives its score from the declared coverage input via verdict.score_source, without a separate caller-supplied score or display rounding. Catalogue validation checks executable grammar, and tests cover RIF and all RRE policy domains. The worked demo binds requirement state row-wise and coverage explicitly; generic binding of array outputs, evaluation of the other composition policies, and quality-metadata interpretation remain outside it. Grammar validation is not a proof that every arbitrary future policy partitions its entire domain; consumer-specific vectors and live admission evidence remain required.
Target-schema completion — activation rules beyond size bands, criterion-level evidence specifications and questionnaire references, from Viroway's rated-company access; the seed's evidence_period values (730 days) are placeholders.
Scheme shortlist — decision on §12.
Assisted submission — the agent that fills a scheme's portal from the evidence pack is a consuming-engine component subject to the scheme's platform terms; outside this catalogue.

15 Stable normative requirements

RRE-REQ-0001 — Scheme rules are reference data

A scheme's activation rules and evidence acceptance rules SHALL be expressed as predicates in a versioned target schema resolved by KISMET-RESOLVER-RRE-TARGET_SCHEMA. No kernel, binding or policy SHALL encode a scheme's rule (§02-1).

RRE-REQ-0002 — Evidence is scoped by the crosswalk

A record SHALL be eligible for a requirement only if offered_for contains that requirement's identifier. KISMET-KERNEL-DATA-REQUIREMENT_MATCH SHALL reject records without offered_for (guard missing_scope) (§02-2, §04.2).

RRE-REQ-0003 — Undetermined is preserved

Missing profile or evidence attributes SHALL yield undetermined, never false, through every kernel and into the gap map and coverage counts (§02-3, §03.1).

RRE-REQ-0004 — Coverage is completeness

Coverage SHALL be computed by KISMET-KERNEL-SCORE-COVERAGE from requirement states, weights and a credit map; no component SHALL present coverage, bands or labels as a prediction of a scheme's score, medal or badge (§02-4, §07.2).

RRE-REQ-0005 — Platform gaps are reported

Activated criteria without crosswalk coverage SHALL be an explicit composition output and labelled "manual evidence required" in the gap map (§02-5, §05.2).

RRE-REQ-0006 — Snapshot pinning

Every execution SHALL pin the target-schema and crosswalk snapshots (cohort_id, snapshot_ref, snapshot_hash) in its manifest; a questionnaire's pinned version SHALL take precedence over the version effective at as_of (§05.1, §11).

RRE-REQ-0007 — Final action is the client's

Nothing in this catalogue, nor in the consuming engine built on it, SHALL submit to an external scheme on a client's behalf. Assisted submission stages and validates; the client submits (ECO-ECOVADIS-PF §10).

RRE-REQ-0008 — Conformance evidence

An implementation of any RRE kernel SHALL reproduce the golden vectors through run_vectors.py before registration; a target schema or crosswalk SHALL pass validate.py before publication in Pergamum Pulse.

GitHub Repo Request for Change (RFC)

00 Document control​

01 Purpose and scope​

02 Design principles​

03 Data model — Pergamum Pulse content​

03.1 Predicate grammar​

03.2 Target schema​

03.3 Crosswalk​

03.4 Canonical evidence record​

04 Kernels (KEC)​

04.1 KISMET-KERNEL-DATA-PREDICATE_EVAL​

04.2 KISMET-KERNEL-DATA-REQUIREMENT_MATCH​

04.3 KISMET-KERNEL-SCORE-COVERAGE​

04.4 KISMET-KERNEL-DATA-SET_DIFF​

05 Resolvers (KRC)​

05.1 KISMET-RESOLVER-RRE-TARGET_SCHEMA​

05.2 KISMET-RESOLVER-RRE-CROSSWALK​

06 Bindings (KBC)​

06.1 KISMET-BINDING-RRE-REQUIREMENT_MATCH​

06.2 KISMET-BINDING-RRE-COVERAGE​

07 Policies (KPC)​

07.1 KISMET-POLICY-RRE-REQUIREMENT_STATUS​

07.2 KISMET-POLICY-RRE-READINESS_BANDS​

08 Composition (KCC)​

09 Execution, evidence and the consuming engine​

10 Worked example​

11 Versioning and methodology currency​

12 Scheme shortlist — what each candidate adds to the model​

13 Conformance​

14 Open items requiring registration or decision​

15 Stable normative requirements​

RRE-REQ-0001 — Scheme rules are reference data​

RRE-REQ-0002 — Evidence is scoped by the crosswalk​

RRE-REQ-0003 — Undetermined is preserved​

RRE-REQ-0004 — Coverage is completeness​

RRE-REQ-0005 — Platform gaps are reported​

RRE-REQ-0006 — Snapshot pinning​

RRE-REQ-0007 — Final action is the client's​

RRE-REQ-0008 — Conformance evidence​