tdln-gate 0.1.1

TDLN — Policy Gate (preflight/decision) with proof-carrying determinism.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! TDLN Policy Gate — preflight & decision, proof-carrying, deterministic.
//!
//! Event sequence (high-level): nl.utterance → plan.proposed → policy.preflight
//! → user.consent → policy.decision → effect.exec → state.update

#![forbid(unsafe_code)]

#[cfg(feature = "dv25")]
use logline_core as _;

use serde::{Deserialize, Serialize};
use tdln_compiler::CompiledIntent;
use thiserror::Error;

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
pub enum Decision {
    Allow,
    Deny,
    NeedsConsent,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LogEvent {
    pub kind: String,
    pub payload: serde_json::Value,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GateOutput {
    pub decision: Decision,
    pub audit: serde_json::Value,
    pub proof_ref: [u8; 32],
    pub events: Vec<LogEvent>,
}

#[derive(Debug, Error)]
pub enum GateError {
    #[error("invalid input")]
    Invalid,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PolicyCtx {
    pub allow_freeform: bool,
}

/// Pré-validação determinística.
///
/// # Errors
///
/// - Retorna `GateError::Invalid` para entradas inválidas (reservado)
pub fn preflight(intent: &CompiledIntent, _ctx: &PolicyCtx) -> Result<GateOutput, GateError> {
    // Minimal deterministic audit
    let audit = serde_json::json!({
        "ast_cid": hex::encode(intent.proof.ast_cid),
        "canon_cid": hex::encode(intent.proof.canon_cid),
    });
    let events = vec![LogEvent {
        kind: "policy.preflight".into(),
        payload: audit.clone(),
    }];
    Ok(GateOutput {
        decision: Decision::NeedsConsent,
        audit,
        proof_ref: intent.cid,
        events,
    })
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Consent {
    pub accepted: bool,
}

/// Decide a partir do consentimento e contexto.
///
/// # Errors
///
/// - Propaga `GateError::Invalid` para entradas inválidas (reservado)
pub fn decide(
    intent: &CompiledIntent,
    consent: &Consent,
    ctx: &PolicyCtx,
) -> Result<GateOutput, GateError> {
    // Deterministic decision with audit trail
    let mut out = preflight(intent, ctx)?;
    let decision = if consent.accepted && ctx.allow_freeform {
        Decision::Allow
    } else if !consent.accepted {
        Decision::NeedsConsent
    } else {
        Decision::Deny
    };
    out.events.push(LogEvent {
        kind: "policy.decision".into(),
        payload: serde_json::json!({ "decision": format!("{:?}", decision) }),
    });
    out.decision = decision;
    Ok(out)
}

#[cfg(test)]
mod tests {
    use super::*;
    use tdln_compiler::{compile, CompileCtx};
    #[test]
    fn pipeline() {
        let ctx = CompileCtx {
            rule_set: "v1".into(),
        };
        let compiled = compile("hello world", &ctx).unwrap();
        let gctx = PolicyCtx {
            allow_freeform: true,
        };
        let pf = preflight(&compiled, &gctx).unwrap();
        assert_eq!(pf.decision, Decision::NeedsConsent);
        let dec = decide(&compiled, &Consent { accepted: true }, &gctx).unwrap();
        assert_eq!(dec.decision, Decision::Allow);
        assert!(dec.events.len() >= 2);
    }
}