Enum SynthesisOutcome 

pub enum SynthesisOutcome {
    Accepted {
        code: String,
        confidence: f64,
        from_cache: bool,
    },
    RuleApplied {
        code: String,
        rule_id: String,
        node_kind: String,
        confidence: f64,
    },
    RejectedLowConfidence {
        confidence: f64,
    },
    RejectedVerification {
        error: String,
    },
    ProviderError {
        message: String,
    },
    ProductionUnpinned,
}

Result of synthesizing a single flagged node.

Variants

Accepted

AI produced code that cleared the confidence threshold (or was replayed from the pinned cache) and passed verification.

Fields

code: String

The synthesized target code snippet.

confidence: f64

Confidence attached by the provider.

from_cache: bool

true when the response came from the content-addressed cache — treated as pinned replay per §17.8 (bypasses threshold).

RuleApplied

A cached codegen rule (§17.7) matched this node’s kind and was applied deterministically — the AI was never called.

Fields

code: String

The code produced by applying the rule’s template.

rule_id: String

Identifier of the rule in the local RuleCache.

node_kind: String

The bock_air::NodeKind discriminant the rule matched.

confidence: f64

Confidence attached to the rule at extraction time.

RejectedLowConfidence

AI produced code but confidence was below the threshold.

Fields

confidence: f64

Confidence reported by the provider.

RejectedVerification

AI produced code but it failed the deterministic verifier (§17.3).

Fields

error: String

The reason verification failed.

ProviderError

Provider call failed (transport, auth, etc.). Tier 2 handles the node.

Fields

message: String

The underlying AI error message.

ProductionUnpinned

Production strictness required a pinned decision but none was available. The caller decides whether to error or fall through.

Trait Implementations

impl Clone for SynthesisOutcome

fn clone(&self) -> SynthesisOutcome

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SynthesisOutcome

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

Formats the value using the given formatter.

impl PartialEq for SynthesisOutcome

fn eq(&self, other: &SynthesisOutcome) -> 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 StructuralPartialEq for SynthesisOutcome