Skip to main content

qualia_core_db/inference/conditioning/
inspector.rs

1//! Conditioning inspector providing redacted requirement/token/evidence traces (PP-081).
2//!
3//! Strictly adheres to IMPLEMENTATION.md ยง7:
4//! "Never expose raw learned tensors, unrestricted prompts, private evidence or cache pages as ordinary Vibe Value data. Use opaque refs and receipts."
5
6use 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
33/// Builds a redacted inspection trace for `spec`.
34pub 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}