qualia_core_db/inference/conditioning/
inspector.rs1use crate::inference::conditioning::requirement::RequirementClass;
7use crate::inference::conditioning::spec::ConditioningSpec;
8
9#[derive(Clone, Debug, PartialEq, Eq)]
10pub struct RedactedRequirement {
11 pub id: String,
12 pub class: &'static str,
13 pub rule: String,
14 pub validator: Option<String>,
15 pub required: bool,
16 pub priority: u8,
17}
18
19#[derive(Clone, Debug, PartialEq, Eq)]
20pub struct RedactedInspectionTrace {
21 pub profile_id: String,
22 pub schema_version: u16,
23 pub plan_identity: Option<u64>,
24 pub input_token_budget: u32,
25 pub output_token_budget: u32,
26 pub tool_rounds_budget: u16,
27 pub requirements: Vec<RedactedRequirement>,
28 pub evidence_count: usize,
29 pub disclosure_ceiling: u8,
30 pub privacy_redaction_applied: bool,
31}
32
33pub fn inspect_spec(
35 spec: &ConditioningSpec,
36 plan_identity: Option<u64>,
37 evidence_count: usize,
38 disclosure_ceiling: u8,
39) -> RedactedInspectionTrace {
40 let mut reqs = Vec::with_capacity(spec.requirements.len());
41 for req in spec.requirements {
42 reqs.push(RedactedRequirement {
43 id: req.id.to_string(),
44 class: match req.class {
45 RequirementClass::Enforced => "enforced",
46 RequirementClass::EvidenceObligation => "evidence_obligation",
47 RequirementClass::Guidance => "guidance",
48 },
49 rule: req.rule.to_string(),
50 validator: req.validator.map(|s| s.to_string()),
51 required: req.required,
52 priority: req.priority,
53 });
54 }
55
56 RedactedInspectionTrace {
57 profile_id: spec.profile_id.to_string(),
58 schema_version: spec.schema_version,
59 plan_identity,
60 input_token_budget: spec.budget.input_tokens,
61 output_token_budget: spec.budget.output_tokens,
62 tool_rounds_budget: spec.budget.tool_rounds,
63 requirements: reqs,
64 evidence_count,
65 disclosure_ceiling,
66 privacy_redaction_applied: true,
67 }
68}
69
70#[cfg(test)]
71mod tests {
72 use super::*;
73 use crate::inference::conditioning::budget::ConditioningBudget;
74 use crate::inference::conditioning::requirement::RequirementRef;
75 use crate::inference::conditioning::spec::OutputContractRef;
76
77 #[test]
78 fn test_inspect_spec_privacy_guarantees() {
79 let reqs = [RequirementRef {
80 id: "R1",
81 class: RequirementClass::Enforced,
82 rule: "Preserve invariants",
83 validator: Some("validator-1"),
84 required: true,
85 priority: 255,
86 }];
87 let spec = ConditioningSpec {
88 schema_version: 1,
89 profile_id: "urn:qualia:profile:test:v1",
90 objective: "Run safe evaluation",
91 requirements: &reqs,
92 domain_refs: &[],
93 output_contract: OutputContractRef {
94 schema_hint: None,
95 min_citations: 0,
96 },
97 budget: ConditioningBudget {
98 input_tokens: 2048,
99 output_tokens: 512,
100 tool_rounds: 2,
101 max_bytes: 8192,
102 thinking_token_budget: None,
103 },
104 };
105
106 let trace = inspect_spec(&spec, Some(0xDEAD_BEEF), 3, 1);
107 assert!(trace.privacy_redaction_applied);
108 assert_eq!(trace.profile_id, "urn:qualia:profile:test:v1");
109 assert_eq!(trace.plan_identity, Some(0xDEAD_BEEF));
110 assert_eq!(trace.evidence_count, 3);
111 assert_eq!(trace.disclosure_ceiling, 1);
112 assert_eq!(trace.requirements.len(), 1);
113 assert_eq!(trace.requirements[0].id, "R1");
114 assert_eq!(trace.requirements[0].class, "enforced");
115 }
116}