Struct ProposedFact 

pub struct ProposedFact {
    pub key: ContextKey,
    pub id: ProposalId,
    pub provenance: Provenance,
    /* private fields */
}

An unvalidated suggestion from a non-authoritative source.

Proposed facts live in ContextKey::Proposals until a ValidationAgent promotes them to Fact. The proposal tracks its origin for audit trail.

Fields

key: ContextKey

The context key this proposal targets.

id: ProposalId

Unique identifier encoding origin and target.

provenance: Provenance

Provenance information (e.g., model ID, prompt hash).

Implementations

impl ProposedFact

pub fn new<T>( key: ContextKey, id: impl Into<ProposalId>, payload: T, provenance: impl Into<Provenance>, ) -> ProposedFact

where T: FactPayload + PartialEq,

Create a new draft proposal with explicit provenance.

Confidence defaults to 1.0. Override with with_confidence.

pub fn from_wire( wire: WireProposedFact, registry: &PayloadRegistry, ) -> Result<ProposedFact, PayloadError>

Materializes a proposal from the stable wire shape at an external border.

pub fn to_wire(&self) -> Result<WireProposedFact, PayloadError>

Converts this proposal to the stable wire shape.

pub fn to_context_fact( &self, id: impl Into<FactId>, promotion_record: FactPromotionRecord, created_at: impl Into<Timestamp>, ) -> ContextFact

Creates a promoted context projection that preserves this proposal’s exact typed payload.

Promotion authority still belongs to the engine/gate. This method only avoids re-serializing or textifying a payload after that authority has already accepted the proposal.

pub fn key(&self) -> ContextKey

Returns the context key this proposal targets.

pub fn id(&self) -> &ProposalId

Returns the proposal identifier.

pub fn payload<T>(&self) -> Option<&T>

where T: FactPayload,

Returns the typed payload when the requested type matches the stored payload family/version.

pub fn require_payload<T>(&self) -> Result<&T, PayloadError>

where T: FactPayload,

Returns the typed payload or a mismatch error.

pub fn payload_family(&self) -> FactFamilyId

Returns the payload family.

pub fn payload_version(&self) -> PayloadVersion

Returns the payload version.

pub fn text(&self) -> Option<&str>

Returns the payload as text when this is a TextPayload.

pub fn validate_payload(&self) -> Result<(), PayloadError>

Validates the stored payload.

pub fn provenance(&self) -> &str

Returns the proposal provenance string.

pub fn confidence(&self) -> f64

Returns the confidence value, always in [0.0, 1.0].

pub fn with_confidence(self, confidence: f64) -> ProposedFact

Set an explicit confidence baseline for this proposal.

Use this to establish a starting point, then accumulate criteria with adjust_confidence. The value is clamped to [0.0, 1.0]; non-finite values (NaN, infinity) are treated as 0.0.

For computed confidence (e.g. from a solver), pass the result directly.

pub fn adjust_confidence(self, delta: f64) -> ProposedFact

Adjust confidence by a named step, clamped to [0.0, 1.0].

This is the recommended way to express confidence in suggestors and pack solvers. Use the CONFIDENCE_STEP_* constants as the vocabulary:

use converge_pack::{CONFIDENCE_STEP_MAJOR, CONFIDENCE_STEP_MINOR, CONFIDENCE_STEP_TINY, TextPayload};

let proposal = EXAMPLE_PROVENANCE.proposed_fact(key, id, TextPayload::new(content))
    .with_confidence(0.5)                        // baseline
    .adjust_confidence(CONFIDENCE_STEP_MAJOR)    // primary criterion met
    .adjust_confidence(CONFIDENCE_STEP_MINOR)    // supporting criterion met
    .adjust_confidence(CONFIDENCE_STEP_TINY);    // tiebreaker bonus

Prefer this over accumulating a local f64 and calling with_confidence at the end — the clamping is automatic and the intent is explicit at each step.

Trait Implementations

impl Clone for ProposedFact

fn clone(&self) -> ProposedFact

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ProposedFact

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for ProposedFact

fn eq(&self, other: &ProposedFact) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ProposedFact

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.