#Unified Scoring Mechanism (USCM)

Pattern A.19.USCM · Stable · Architectural (A) · Normative (unless explicitly marked informative) Part A - Kernel Architecture Cluster

Type: Architectural (A) Status: Stable Normativity: Normative (unless explicitly marked informative) Placement: Part A / CN‑Spec cluster (A.19) / CHR mechanism owner patterns (Phase‑3) Source: FPF / CHR Phase‑3 mechanism owner patterns Modified: 2026‑01‑20

Semantic owner note, Phase‑3 canonicalization: this pattern is the designated single semantic owner of the canonical U.Mechanism.Intension for USCM.IntensionRef (CHR suite stage score). This matches the single‑owner discipline: mechanism‑intension semantics of characterisation mechanisms live in an explicitly designated mechanism‑owner pattern (E.20). A.6.1 remains the owner of the template of U.Mechanism.Intension; this pattern owns the USCM‑specific slots, operations, laws, admissibility, applicability, transport, plane, and audit obligations for that template (single‑owner at the instance‑semantics level).

Canonicalization hook, ID‑continuity‑safe: any other appearances of the USCM intension (e.g., a legacy grounding stub in A.6.1 or suite prose in A.19.CHR) SHALL be reduced to a Tell + Cite stub pointing to A.19.USCM:4.1, while preserving the original section headings and their public PatternId:SectionPath IDs for continuity (alias‑dock legacy tokens rather than deleting them). Such stubs MUST NOT restate SlotIndex, OperationAlgebra, LawSet, Admissibility, or Audit content (no “second center of gravity” via near‑duplicate prose).

• Suite stage: score (ordering lives only in A.19.CHR:4.5 / suite_protocols; suite membership is a set in A.19.CHR:4.2).
• Inputs, conceptual: an admitted measure profile (InputProfileSlot) + CNSpecRef + CGSpecRef + ScoringMethodDescriptionRef + active U.BoundedContextRef, with optional MinimalEvidenceRef override.
• Output: ScoreProfileSlot = a set of score measures (vector scores are first‑class; a scalar score is allowed only if explicitly declared).
• Non‑goals: does not normalize (UNM), aggregate (ULSAM), compare (CPM), select (SelectorMechanism), threshold, publish, or emit telemetry; it is a scoring step with explicit legality and evidence surfaces.
• P2W seam: concrete edition/policy pin bindings (including ScoringMethodDescriptionRef@edition(…) when USCM is used) are chosen in planned baseline artefacts (A.15.3 + A.19.CHR:4.7.2); executions only record effective refs/pins in Audit.
• Failure mode: tri‑state guard (pass|degrade|abstain); unknown never coerces to pass, and MUST NOT be coerced to 0/false.
• Quick rule of thumb: if CGSpecSlot.SCP is missing → ScoreEligibility = abstain (fail‑closed); if ScoringMethodDescriptionSlot is missing → ScoreEligibility = abstain (no implicit scoring method); if CN‑Spec.comparability requires normalization‑based comparability → normalization MUST be explicit in choreography (Uses/pins), never hidden inside Score.

#Keywords

• scoring
• score profile
• ScoringMethodDescription
• ScaleComplianceProfile (SCP)
• CSLC-lawful transforms
• CG-Spec.MinimalEvidence
• tri-state admissibility (pass|degrade|abstain)
• “no implicit UNM”
• vector scores by default
• CHR suite stage score.

#Relations

#Content

#At a glance — didactic, informative

• Suite stage: score (ordering lives only in A.19.CHR:4.5 / suite_protocols; suite membership is a set in A.19.CHR:4.2).
• Inputs, conceptual: an admitted measure profile (InputProfileSlot) + CNSpecRef + CGSpecRef + ScoringMethodDescriptionRef + active U.BoundedContextRef, with optional MinimalEvidenceRef override.
• Output: ScoreProfileSlot = a set of score measures (vector scores are first‑class; a scalar score is allowed only if explicitly declared).
• Non‑goals: does not normalize (UNM), aggregate (ULSAM), compare (CPM), select (SelectorMechanism), threshold, publish, or emit telemetry; it is a scoring step with explicit legality and evidence surfaces.
• P2W seam: concrete edition/policy pin bindings (including ScoringMethodDescriptionRef@edition(…) when USCM is used) are chosen in planned baseline artefacts (A.15.3 + A.19.CHR:4.7.2); executions only record effective refs/pins in Audit.
• Failure mode: tri‑state guard (pass|degrade|abstain); unknown never coerces to pass, and MUST NOT be coerced to 0/false.
• Quick rule of thumb: if CGSpecSlot.SCP is missing → ScoreEligibility = abstain (fail‑closed); if ScoringMethodDescriptionSlot is missing → ScoreEligibility = abstain (no implicit scoring method); if CN‑Spec.comparability requires normalization‑based comparability → normalization MUST be explicit in choreography (Uses/pins), never hidden inside Score.

#Problem frame

FPF’s Characterization (CHR) suite treats scoring as a distinct mechanism boundary within the CHR suite (authoritative membership: A.19.CHR:4.2). Suite membership is a set (order has no semantics); any intended ordering is expressed only via suite_protocols (A.19.CHR:4.5), under the suite obligations (A.19.CHR:4.3).

Within the canonical suite‑closed protocol, USCM appears as the score stage (after normalize and indicatorize, before comparison and selection). USCM’s surface is legality‑first: it produces score measures from admitted profiles while remaining constrained by the legality gate (CG‑Spec.SCP) and by scale‑lawfulness (CSLC).

USCM exists to keep a strict distinction between:

• normalization (UNM),
• indicatorization (UINDM),
• scoring (USCM),
• aggregation/folding (ULSAM), and
• comparison/ordering/selection (CPM + SelectorMechanism),

so that each commitment has a single place to live, can be audited, and can evolve without smuggling extra semantics into adjacent steps.

#Problem

Engineering teams often need to convert an admitted (indicator or NCV) profile into one or more score measures for downstream comparison and selection. If scoring is not given a first‑class mechanism boundary with explicit legality and evidence surfaces, the following failure modes are common:

• Illicit arithmetic by convenience: teams apply weighted sums, averages, or nonlinear transforms across mixed scale kinds without an explicit legality profile, creating scores that are not CSLC‑lawful.
• Hidden normalization: scoring implementations silently normalize, align, or flip polarities, collapsing the distinction between “normalize” and “score” and making downstream reasoning non‑reproducible.
• Silent scalarization: multi‑criteria realities (vector scores, partial‑order comparability) are reduced to a single scalar via hidden tie‑breakers, producing an apparent total order that is not justified.
• Unknown coercion: missing or insufficient evidence is coerced into 0/false or treated as “good enough,” yielding scores that look precise while being epistemically unsafe.
• Drift and non‑auditability: different teams score “the same thing” differently because legality constraints and effective policies (editions, evidence rules, crossings) are not explicit and not recorded.

#Forces

1. Legality discipline vs operational pressure. Scoring is where “just compute a number” pressure is strongest, but legality must remain explicit and checkable: SCP and CSLC constraints must bound permissible transforms.

2. Method diversity vs stable mechanism boundary. Scoring methods evolve rapidly; USCM’s signature must remain stable so method families can be wired through SoTA packs and extensions without mutating the mechanism boundary.

3. Vector reality vs scalar simplicity. Many situations require multiple score dimensions. A single scalar score may be convenient but must be an explicit, declared commitment, not a hidden reduction.

4. Uncertainty vs decisiveness. Teams need decisions under uncertainty; the framework must prevent epistemic overconfidence. Tri‑state admissibility guards preserve correctness without forcing silent coercions.

5. Strict distinction across CHR steps. USCM must not absorb UNM, ULSAM, or CPM semantics “for convenience,” or the suite becomes opaque and non‑teachable.

6. Evolvability vs didactic usability. Interfaces must remain evolvable (stable SlotKind surface; method semantics externalized), while the spec remains teachable: a reader must find USCM’s purpose, boundary, laws, guard behavior, and audit minimum in one place.

7. P2W separation and gate/guard separation. Planned baseline binding (editions/policy ids) belongs to WorkPlanning artefacts; gate decisions and logs live in gate patterns / WorkEnactment. USCM must expose eligibility + audit pins without turning into a gate or a planner.

#Solution

USCM is the canonical scoring mechanism in the CHR suite. It defines:

• a stable mechanism boundary (score is its own stage with a canonical Score operation and a tri‑state eligibility predicate),
• a stable SlotKind surface (via the suite lexicon),
• a legality‑first LawSet anchored in CG‑Spec.SCP and CSLC,
• an explicit anti‑smuggling rule (no implicit normalization), and
• an audit minimum (edition pins and effective evidence policy, plus crossings when transport occurs).

USCM preserves the suite obligations by construction: it does not embed GateDecision/GateLog, it does not perform publish/telemetry steps, and it keeps Transport declarative (refs/pins only) with penalties routed to R_eff only.

Method semantics (“how to score”) remain out of suite core: they belong in SoTA packs (G.2) and wiring‑only extension modules (GPatternExtension blocks), while USCM remains the stable conceptual mechanism boundary.

#Mechanism.Intension

This is the canonical U.Mechanism.Intension for USCM.IntensionRef and is intended to be cited by CHR suite artifacts and by any wiring layers.

• Scope note: this intension is an instance authored to the U.Mechanism.Intension shape owned by A.6.1. It defines only the mechanism’s semantic surface (slots/ops/laws/guards/audit). It does not bind project‑specific pins (P2W), and it does not emit GateDecision/GateLog; it emits Audit pins and a tri‑state guard only.

• IntensionHeader: id = USCM, version = 1.0.0, status = stable.

• IntensionRef: USCM.IntensionRef (canonical target for the suite member named in A.19.CHR:4.2).

• SignatureManifest (optional; importability): if a USCM publication is intended to be imported/reused, it SHOULD publish a SignatureManifest (A.6.0 / A.6.1; CC‑A.6.0‑18, CC‑UM.1) consistent with IntensionHeader/Imports, explicitly exposing the stable SlotKind surface (including ScoringMethodDescriptionSlot) and any declared scalarization commitment.

• Tell. SCP‑first scoring: produce score measures from admitted profiles without violating CSLC / scale legality.

• Purpose: SCP‑first scoring: produce score measures from admitted profiles without violating CSLC / scale legality.

• Imports: G.0 (CG‑Spec.SCP, CG‑Spec.MinimalEvidence), A.18 (CSLC), C.16 (ScoringMethod disclosure + polarity/monotonicity discipline), A.19.CN (comparability.mode + normalization routing), A.19.CHR:4.2.1 (CHR SlotKind Lexicon).

• SubjectBlock:

  • SubjectKind: Scoring.
  • BaseType: U.Measure.
  • SliceSet: U.ContextSliceSet.
  • ExtentRule: scoring ranges over admitted (indicator/NCV) profiles in the active context slice, routed by CN‑Spec.comparability and legality‑gated by CG‑Spec.SCP.
  • ResultKind?: U.Set (of U.Measure).

• SlotIndex (derived projection from SlotSpecs / guard SlotSpecs; uses A.19.CHR:4.2.1 SlotKind tokens where applicable; any new SlotKind tokens introduced here MUST be suite‑docked into the lexicon by the suite owner to avoid drift):

  • InputProfileSlot : ⟨ValueKind = U.Set (of U.Measure), refMode = ByValue⟩,
  • CNSpecSlot : ⟨ValueKind = CN‑Spec, refMode = CNSpecRef⟩,
  • CGSpecSlot : ⟨ValueKind = CG‑Spec, refMode = CGSpecRef⟩,
  • ScoringMethodDescriptionSlot : ⟨ValueKind = ScoringMethodDescription, refMode = ScoringMethodDescriptionRef⟩ (SlotKind token; when reproducibility matters it is edition‑pinned via the P2W baseline; if the suite lexicon does not yet contain this token, it SHALL be docked into the lexicon by the suite owner rather than introduced ad‑hoc),
  • ContextSlot : ⟨ValueKind = U.BoundedContext, refMode = U.BoundedContextRef⟩,
  • MinimalEvidenceSlot? : ⟨ValueKind = MinimalEvidence, refMode = MinimalEvidenceRef⟩ (optional override; otherwise cite CGSpecSlot.MinimalEvidence),
  • ScoreProfileSlot : ⟨ValueKind = U.Set (of U.Measure), refMode = ByValue⟩.

• OperationAlgebra (suite stage = score, per A.19.CHR:4.5; canonical stage‑op = Score):

  • Score(InputProfileSlot, CNSpecSlot, CGSpecSlot, ScoringMethodDescriptionSlot, ContextSlot, MinimalEvidenceSlot?) → ScoreProfileSlot.

• LawSet (minimum; legality‑first, no hidden scalarization):

  1. SCP+CSLC legality: any numeric transform used to produce ScoreProfileSlot MUST be admissible under CGSpecSlot.SCP and CSLC‑lawful (cites G.0 + A.18).
  2. ScoringMethod is explicit (no hidden defaults): Score MUST cite ScoringMethodDescriptionSlot (edition‑pinned via P2W when reproducibility matters; see A.19.CHR:4.7.2). If a score is issued, the scoring method 𝒢 (Coordinate→Score) MUST be disclosed as required by C.16 (bounded codomain; monotonicity consistent with template polarity). USCM MUST NOT rely on an implicit “default scoring method”.
  3. No implicit normalization: Score MUST NOT silently perform UNM; if CNSpecSlot.comparability requires normalization‑based comparability, the normalization step MUST be explicit in choreography (Uses/pins), not hidden in Score.
  4. Vector scores allowed; scalarization must be explicit: producing a single scalar score is allowed only if explicitly declared (e.g., by fixing ScoreProfileSlot cardinality to 1 and citing the lawful transform); partial‑order semantics MUST NOT be silently reduced to a scalar “tie‑breaker”.
  5. Unknown is not coerced: unknown / insufficient evidence MUST NOT be mapped to 0/false; use tri‑state guards and explicit failure behavior.

• AdmissibilityConditions (tri‑state guard; fail‑closed on missing legality/evidence):

  • ScoreEligibility(InputProfileSlot, CNSpecSlot, CGSpecSlot, ScoringMethodDescriptionSlot, ContextSlot, MinimalEvidenceSlot?) → GuardDecision ∈ {pass|degrade|abstain}.
  • pass requires: (i) CGSpecSlot.SCP is present, (ii) ScoringMethodDescriptionSlot is present (no implicit scoring method), (iii) evidence passes MinimalEvidenceSlot? or CGSpecSlot.MinimalEvidence, and (iv) CN‑Spec.comparability routing is satisfied (incl. explicit UNM when needed).
  • If MinimalEvidenceSlot is absent, the guard MUST evaluate evidence against CGSpecSlot.MinimalEvidence (by explicit rule), and MUST NOT return pass when evidence is missing/unknown.
  • If ScoringMethodDescriptionSlot is missing or unpinned/ambiguous under the active planned baseline, the guard MUST return abstain (fail‑closed), not “assume a default”.

• Applicability:

  • Intended to be used after indicatorization (when indicator profiles are used) and before comparison/selection.
  • Applicable only when legality/evidence surfaces are present via CGSpecSlot (fail‑closed otherwise).
  • Applicable only when a scoring method is explicitly declared via ScoringMethodDescriptionSlot (edition‑pinned when reproducibility matters). A “do nothing / identity scoring” intent (if ever needed) MUST still be declared as an explicit scoring method description, not as an implicit default.

• Transport: Bridge+CL/ReferencePlane only; penalties route to R_eff only.

• Γ_timePolicy: point by default (no implicit “latest”).

• PlaneRegime: values live on episteme ReferencePlane; on plane crossings apply CL^plane policy; penalties → R_eff only.

• Audit:

  • MUST record: CNSpecRef.edition, CGSpecRef.edition, ScoringMethodDescriptionRef.edition.
  • MUST record the effective evidence policy:
    • if MinimalEvidenceSlot? is present → record MinimalEvidenceRef as effective;
    • otherwise → cite CGSpecSlot.MinimalEvidence as effective.
  • SHOULD record the realized GuardDecision for ScoreEligibility, and (when degrade/abstain) the referenced failure behavior / downstream handling policy id (e.g., SoS‑LOG branch id) when such a policy is in scope.
  • SHOULD record: a stable description of ScoreProfileSlot, any Bridge/CL/ReferencePlane ids when Transport was invoked, and (when normalization‑based comparability was required) an explicit ref/pin that the upstream UNM step was applied (no provenance gaps for “normalized input” claims).

#Interpretation notes — informative

• A score profile is a set of measures. ScoreProfileSlot is a U.Set (of U.Measure). Treat this as “vector scoring by default.” If a project truly needs a single scalar score, declare that explicitly (per LawSet item 3), rather than assuming scalarity.

• A score profile is a set of measures. ScoreProfileSlot is a U.Set (of U.Measure). Treat this as “vector scoring by default.” If a project truly needs a single scalar score, declare that explicitly (per LawSet item 4), rather than assuming scalarity.

• USCM does not order; it scores. USCM produces score measures. Any ordering, dominance, or set‑valued comparison is performed by CPM and SelectorMechanism (and any optional aggregation is made explicit via ULSAM). Treating the score as “the decision” is a category error in CHR terms.

• ScoringMethod is explicit (no hidden defaults). USCM requires ScoringMethodDescriptionSlot: the scoring method is a first‑class, auditable choice (typically pinned in planned baseline). This keeps “how we score” evolvable (wired via method packs) without making it implicit or accidental.

• No implicit UNM is a boundary guard. This discourages convenience implementations that “just normalize inside scoring.” USCM forbids that: if comparability requires normalization‑based routing, the UNM step is explicit in choreography (Uses/pins) and visible in audit surfaces.

• Evidence policy is explicit and auditable. MinimalEvidenceSlot? is an optional override; otherwise the effective policy is CGSpecSlot.MinimalEvidence. Failures do not disappear; they must show up as degrade/abstain and be traceable.

• Crossings are declarative and penalize R_eff only. When scoring spans contexts or planes, USCM names Bridge+CL/ReferencePlane policies and routes penalties to R_eff only, keeping correctness separate from convenience.

#Archetypal Grounding — informative

#Tell

Think of USCM as legality‑gated scoring:

• Input: “an admitted profile of measures, in this context slice, plus CN-Spec governance card and CG-Spec legality gate”
• Output: “a set of score measures that downstream steps may compare/select on”

The key didactic boundary is: USCM is allowed to transform measures only within the legality surface (SCP+CSLC), and it must not hide normalization, aggregation, or ordering.

#Show — U.System

A program manager evaluates competing rollout plans for a product launch.

• The admitted profile includes measures like {Cost, LeadTime, Reliability, RiskExposure, CarbonPerUnit}.
• The CG‑Spec’s SCP admits only scale‑lawful transforms (e.g., monotone transforms on ratio/interval measures, explicit unit alignment rules, and prohibited operations on ordinal measures).
• USCM runs Score(...) and outputs a score profile such as {UtilityScore, RiskScore} rather than forcing a single number.
• A plan lacks sufficient evidence for RiskExposure in this context slice; ScoreEligibility returns degrade, and the audit records the effective MinimalEvidence policy and the editions of CNSpecRef and CGSpecRef.

Downstream steps can now compare and select with an explicit audit trail, instead of pretending that “the score was objective.”

#Show — U.Episteme

A research lead compares several model families for deployment across heterogeneous environments.

• Indicators include calibration and robustness metrics; scoring is done using a calibrated probabilistic score plus uncertainty‑aware score dimensions.
• A post‑2015 practice example is to keep monotonicity and interpretability constraints explicit (e.g., monotone additive models or monotone deep lattice style models) and to treat uncertainty as first‑class (e.g., conformal set‑valued scoring that yields intervals rather than point scores).
• USCM produces a score profile that can remain vector‑valued and uncertainty‑aware, and it refuses to coerce “unknown” into a point score. Comparisons and selections occur downstream using set‑valued semantics where appropriate.

#Bias-Annotation — informative

• Gov (governance). Bias toward explicit legality and evidence surfaces (CGSpecRef, SCP, MinimalEvidence) rather than “standard practice” arithmetic. Risk: perceived overhead. Mitigation: keep the kernel signature small and push method specifics into SoTA packs and wiring modules.

• Arch (architecture). Bias toward stable interfaces and strict step boundaries (no implicit UNM; no hidden scalarization). Risk: reduced room for ad‑hoc shortcuts. Mitigation: allow richer scoring method families via wiring, without mutating the USCM intension.

• Onto/Epist. Bias toward treating scores as measures with declared semantics, not as “the truth.” Risk: teams accustomed to one‑number rankings may resist. Mitigation: treat scalarization as an explicit, auditable commitment, not as the default.

• Prag (pragmatics). Bias toward fail‑closed guards and traceability under uncertainty. Risk: more degrade/abstain outcomes early. Mitigation: couple degrade with explicit downstream behavior policies, rather than silent coercion.

• Did (didactics). Bias toward “one place to learn the mechanism”: the problem/forces/solution narrative is co‑located with the canonical Mechanism.Intension.

#Conformance Checklist

A USCM publication / usage is conformant if it satisfies:

1. Mechanism.Intension completeness. The publication includes the full intension shape (header/imports/subject/slot index/op algebra/laws/admissibility/applicability/transport/time/plane/audit), and uses the tri‑state guard form. SlotIndex is treated as a derived projection. (See CC‑UM.*.)

2. SlotKind discipline. SlotKind tokens match the CHR SlotKind lexicon for the roles used (InputProfileSlot, CNSpecSlot, CGSpecSlot, ContextSlot, MinimalEvidenceSlot, ScoringMethodDescriptionSlot, ScoreProfileSlot). If ScoringMethodDescriptionSlot (or any other required token) is missing from the suite lexicon, it SHALL be suite‑docked there (alias docking acceptable) rather than introduced ad‑hoc in the mechanism.

3. SCP+CSLC legality is enforced. Any numeric transform used to produce score measures is admissible under CGSpecSlot.SCP and CSLC‑lawful; illicit operations (especially “convenient arithmetic” over non‑lawful scales) are excluded.

4. ScoringMethod is explicit and auditable. Score cites ScoringMethodDescriptionSlot (edition‑pinned when reproducibility matters). No implicit “default scoring method” is assumed. The disclosed method respects polarity/monotonicity discipline (cf. C.16).

5. No implicit normalization. Score does not silently perform UNM. If CN‑Spec.comparability requires normalization‑based routing, the normalization step is explicit in choreography (Uses/pins) and auditable.

6. No hidden scalarization. Vector scores are permitted. A scalar score is produced only when explicitly declared, and partial‑order semantics are not reduced to a scalar tie‑breaker.

7. Unknown and evidence handling is explicit. Unknown / insufficient evidence is not coerced to 0/false. Eligibility uses GuardDecision ∈ {pass|degrade|abstain} and evaluates evidence against the effective policy (MinimalEvidenceSlot override or CGSpecSlot.MinimalEvidence).

8. P2W seam is preserved. Planned slot fillings / edition pin bindings are not authored inside the mechanism intension; they are bound in WorkPlanning artefacts (P2W) and surfaced at run‑time only via Audit refs/pins.

9. Transport and plane discipline. Cross‑context and cross‑plane use is declarative (Bridge+CL/ReferencePlane; CL^plane for plane crossings) and routes penalties to R_eff only. Audit records crossings when invoked.

10. Specialization discipline, if extended. Any specialization of USCM (⊑/⊑⁺) follows the multi‑level specialization discipline (A.6.1:4.2.1, CC‑UM.8): SlotKind invariance for inherited ops, no new mandatory inputs to the inherited Score op, and any extra outputs or ops expressed only via ⊑⁺.

#Common Anti‑Patterns and How to Avoid Them

• Hidden normalization inside scoring. Scoring silently normalizes or aligns measures. Avoid by making UNM explicit in choreography and keeping USCM’s Score legality‑only.

• Weighted sum across mixed or non‑lawful scales. Treating “weights + sum” as universal. Avoid by requiring SCP+CSLC admissibility; if it’s not lawful, it’s not admissible.

• Silent scalarization. Collapsing vector scores or partial orders into a single “overall score” via an untracked tie‑breaker. Avoid by leaving vector scores intact, and making scalarization an explicit declared commitment.

• Implicit scoring method (“we just use the standard formula”). The scoring method is assumed rather than declared and pinned. Avoid by requiring ScoringMethodDescriptionSlot and edition pinning in planned baseline; treat “identity scoring” (if ever needed) as an explicit method description, not a hidden default.

• Unknown → 0 coercion. Treating missing evidence as zero, false, or “good enough.” Avoid by tri‑state guards and explicit failure behavior, with auditable effective evidence policy.

• Shadow CG‑Spec. Hard‑coding legality rules inside a scoring method description instead of citing CGSpecSlot.SCP. Avoid by keeping legality in CG‑Spec and treating method details as wiring.

• Telemetry or publish leakage. Treating scoring as a reporting step. Avoid by keeping publish/telemetry outside suite closure (e.g., routed via appropriate post‑suite mechanisms).

• SlotKind drift. Renaming or re‑purposing slots across specializations or across mechanisms. Avoid by using the suite SlotKind lexicon and the ⊑/⊑⁺ discipline.

#Consequences

Benefits

• Makes scoring a first‑class, legality‑gated CHR step, reducing illicit arithmetic and silent assumptions.
• Improves auditability and reproducibility via explicit edition pins and explicit evidence policy selection (override vs default).
• Preserves evolvability: scoring method families can change via SoTA wiring without changing the USCM intension.
• Supports correctness under uncertainty via tri‑state guards and explicit unknown handling.

Costs / trade‑offs

• Requires explicit CG‑Spec legality surfaces (SCP) and explicit evidence policies to achieve pass; this can feel slower than “just compute a score.”
• Vector scores can be less immediately comfortable than a single number; downstream comparison/selection must be explicit about how vector scores are used.

#Rationale

Scoring is a frequent source of semantic precision loss: it is easy to smuggle normalization, illegal arithmetic, implicit thresholds, and uncertainty coercion into “a simple scoring function.” USCM prevents that by forcing a clean boundary:

• Legality first: all transforms are justified by CG‑Spec.SCP and CSLC.
• No hidden steps: normalization is explicit (UNM), aggregation is explicit (ULSAM), ordering is explicit (CPM/SelectorMechanism).
• Uncertainty is visible: admissibility is tri‑state; unknown is not coerced.
• Audit is minimal yet decisive: effective editions and effective evidence policy are always traceable.

This increases both evolvability (stable interface, externalized method semantics) and didactic usability (a single place to learn USCM’s boundary and obligations).

#SoTA-Echoing

SoTA vs popular note. This section records alignment to post‑2015 evidence‑backed practice. It is not a mandate to use fashionable methods; method semantics stay in SoTA packs (G.2) and wiring modules, while this pattern fixes the stable mechanism boundary.

Pack note, Phase‑3: this pattern does not currently cite a USCM‑specific G.2 SoTA pack or ClaimSheet. If/when such a pack is introduced, ScoringMethodDescriptionSlot SHOULD be wired to ScoringMethodDescriptionRef(ed=…) entries owned by that pack’s ClaimSheets, keeping the USCM mechanism semantics unchanged.

#SoTA alignment map

Notes per row

1. USCM does not “implement a particular scoring model”; it preserves a stable, legality‑gated surface on which such models can be wired.
2. Calibration is treated as a lawful transform family that must live within SCP+CSLC; the kernel does not mandate a specific calibration method.
3. Set‑valued scoring aligns with USCM’s “vector first, scalar by declaration” law, and is naturally consumed by CPM/SelectorMechanism without forcing a spurious total order.
4. Single‑owner traceability is used here to keep the spec teachable and non‑duplicative; it does not add new governance cards or legality gates.

#Relations

• Builds on

  • A.6.1 / CC‑UM.* (mechanism intension shape and authoring checks).
  • A.19.CHR:4.2.1 (CHR SlotKind lexicon).
  • G.0 (CG‑Spec, specifically SCP and MinimalEvidence).
  • A.18 (CSLC legality discipline).
  • C.16 (ScoringMethod disclosure; polarity/monotonicity discipline for score mappings).
  • A.15.3 + A.19.CHR:4.7.2 (P2W planned baseline seam for edition/policy pin bindings; cited as seam, not duplicated in Intension).
  • A.19.CN (CN‑Spec, specifically comparability routing and normalization‑based comparability expectations).

• Used by

  • A.19.CHR (suite membership and suite protocols; USCM is the score stage).
  • Downstream CHR stages that require score measures as inputs (e.g., CPM, SelectorMechanism).
  • E.18 (E.TGA) when USCM instances are used as transduction nodes; the selected ScoringMethodDescriptionRef@edition(…) and other pins live in planned baselines (P2W), while executions surface effective refs/pins via Audit.

• Coordinates with

  • UNM when CN‑Spec.comparability requires normalization‑based comparability (explicit choreography, no hidden UNM).
  • ULSAM when folding/aggregation is needed as a distinct, explicit step.
  • G.2 and GPatternExtension wiring modules for post‑2015 method families, without mutating the USCM kernel.
  • E.20 (single‑owner discipline) and F.18 (alias docking) for Phase‑3 canonicalization and ID continuity.

#A.19.USCM:End