Struct GoldenCase 

pub struct GoldenCase {

    pub query: String,
    pub expect: Vec<String>,
    pub garbage: bool,
    pub context_must: Vec<String>,
    pub context_must_not: Vec<String>,
    pub context_edges_must: Vec<ContextEdgeExpectation>,
    pub route_relation_must: Vec<RelationMatchExpectation>,
    pub expected_focus_route: Option<String>,
    pub expected_focus_routes: Vec<String>,
    pub expected_compound_primary: Option<String>,
    pub expected_vocabulary_gap_terms: Vec<String>,
    pub expected_no_vocabulary_gap: bool,
    pub expected_vocab_editable_targets: Vec<String>,
    pub expected_vocab_non_editable_targets: Vec<String>,
    pub expected_omitted_context: Vec<ContextOmissionExpectation>,
    pub expected_omitted_compound_anchors: Vec<ContextOmissionExpectation>,
    pub min_confidence: Option<String>,
    pub expected_confidence: Option<String>,
    pub expected_partition: Option<String>,
    pub combo: Option<String>,
    pub tool: Option<String>,
    pub target_node: Option<String>,
    pub expected_pass: Option<bool>,
    pub file: Option<String>,
    pub line_start: Option<usize>,
    pub line_end: Option<usize>,
    pub quote: Option<String>,
    pub expected_holds: Option<bool>,
    pub class: Option<String>,
    pub difficulty: Option<String>,
    pub requires_code: bool,
    pub requires_docs: bool,
    pub expected_operators: Vec<String>,
    pub expected_required_checks: Vec<String>,
    pub expected_risk_hints: Vec<String>,
    pub expected_profile: Option<String>,
}

One golden judgment. expect is the set of acceptable node ids (any one counts as a correct top hit). garbage marks a nonsense query that MUST be rejected.

Fields

query: String

expect: Vec<String>

garbage: bool

context_must: Vec<String>

Node ids that SHOULD appear in the activated context for this query (support recall).

context_must_not: Vec<String>

Node ids that should NOT appear in the context (noise — e.g. a spurious mention leak).

context_edges_must: Vec<ContextEdgeExpectation>

Directed relation edges that SHOULD appear in the focused context.

route_relation_must: Vec<RelationMatchExpectation>

Structured relation evidence that SHOULD justify the top route hit.

expected_focus_route: Option<String>

Optional focused-route node id expected after graph-aware route selection.

expected_focus_routes: Vec<String>

Optional set of focused-route node ids accepted for graph-aware route selection. Use when a type and the helper that materializes it are both valid anchors for the same agent task.

expected_compound_primary: Option<String>

Optional compound primary node id expected for multi-anchor/faceted focus queries.

expected_vocabulary_gap_terms: Vec<String>

Vocabulary-gap terms expected from compound focus.

expected_no_vocabulary_gap: bool

Whether compound focus is expected to produce no vocabulary gap.

expected_vocab_editable_targets: Vec<String>

Editable vocabulary-repair targets expected from compound focus.

expected_vocab_non_editable_targets: Vec<String>

Non-editable vocabulary-repair targets expected from compound focus.

expected_omitted_context: Vec<ContextOmissionExpectation>

Context candidates that should be reported as considered but omitted from focus.

expected_omitted_compound_anchors: Vec<ContextOmissionExpectation>

Compound anchors that should be reported as considered but omitted from the selected multi-anchor interpretation.

min_confidence: Option<String>

Optional minimum confidence band required for the top route hit.

expected_confidence: Option<String>

Optional exact confidence band expected for the top route hit.

expected_partition: Option<String>

Optional generated EKF partition expected for the top/focused route node.

combo: Option<String>

Optional package combo evaluator id, e.g. ground_gate or verify_receipt.

tool: Option<String>

Optional tool id used by combo evaluators that exercise a concrete MCP/engine tool.

target_node: Option<String>

Optional target node for combo evaluators that attach an operation to an existing node.

expected_pass: Option<bool>

Expected boolean result for combo evaluators with pass/fail semantics.

file: Option<String>

Receipt file for verify_receipt combo cases. Relative paths resolve from package root.

line_start: Option<usize>

1-indexed receipt start line for verify_receipt.

line_end: Option<usize>

Optional 1-indexed receipt end line for verify_receipt.

quote: Option<String>

Expected quote for verify_receipt.

expected_holds: Option<bool>

Expected verify_receipt result.

class: Option<String>

Optional intent-class tag (capability, exact-lookup, troubleshoot, ambiguous, garbage-*, …) — aggregated per class in the report so a large stratified set shows where it’s weak.

difficulty: Option<String>

Optional dogfood difficulty bucket: easy, intermediate, or complex.

requires_code: bool

Whether the task should pull at least one code node into focused context.

requires_docs: bool

Whether the task should pull at least one docs/skill/section node into focused context.

expected_operators: Vec<String>

Operators that should appear in the brief decomposition, serialized as snake_case names.

expected_required_checks: Vec<String>

Required checks that should be present in the selected brief/decomposition.

expected_risk_hints: Vec<String>

Risk/review hint titles that should be present in the selected brief/decomposition.

expected_profile: Option<String>

EKF workflow profile id expected for package-level workflow planning.

Trait Implementations

impl Clone for GoldenCase

fn clone(&self) -> GoldenCase

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GoldenCase

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

Formats the value using the given formatter.

impl Default for GoldenCase

fn default() -> GoldenCase

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for GoldenCase

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for GoldenCase

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.