zagens-cli 0.8.3

Zagens headless CLI + HTTP/SSE runtime sidecar (`zagens`, `zagens-runtime` binaries)
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181

//! Completion-gate panel JSON for LHT UI (P2 — composable harness observability).

use serde::Serialize;
use serde_json::Value;

/// Live completion-gate counters for the harness panel (fed by status events + engine session).
#[derive(Debug, Clone, Default, Serialize)]
#[serde(default)]
pub struct CompletionGatePanelJson {
    /// True when `[long_horizon.completion_gate]` manifest is non-empty.
    pub active: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mode: Option<String>,
    /// Generic layer-2: model `[verify:]` replay mode (`off`/`observe`/`enforce`).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auto_verify_replay: Option<String>,
    /// Generic layer-2: toolchain build/test gate mode (`off`/`observe`/`enforce`).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub toolchain_gate: Option<String>,
    pub manifest_round: u32,
    pub audit_round: u32,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub first_gap_count: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub integration_gap_count: Option<u32>,
    pub gate_reinject_while_blocked: u32,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_manifest_passed: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_audit_pass: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_unmet_reason: Option<String>,
}

/// Merge event-derived cache fields with optional live engine session counters.
#[must_use]
pub fn merge_completion_gate_panel(
    cache: &CompletionGatePanelCache,
    session: Option<CompletionGateSessionSnapshot>,
) -> CompletionGatePanelJson {
    let mut out = CompletionGatePanelJson {
        active: cache.active,
        mode: cache.mode.clone(),
        auto_verify_replay: None,
        toolchain_gate: None,
        manifest_round: cache.manifest_round,
        audit_round: cache.audit_round,
        first_gap_count: cache.first_gap_count,
        integration_gap_count: cache.integration_gap_count,
        gate_reinject_while_blocked: cache.gate_reinject_while_blocked,
        last_manifest_passed: cache.last_manifest_passed,
        last_audit_pass: cache.last_audit_pass,
        last_unmet_reason: cache.last_unmet_reason.clone(),
    };
    if let Some(s) = session {
        out.manifest_round = out.manifest_round.max(s.manifest_gate_rounds);
        out.audit_round = out.audit_round.max(s.audit_rounds);
        out.gate_reinject_while_blocked = out
            .gate_reinject_while_blocked
            .max(s.gate_reinject_while_blocked);
        if out.first_gap_count.is_none() {
            out.first_gap_count = s.first_gap_count;
        }
        if out.integration_gap_count.is_none() {
            out.integration_gap_count = s.integration_gap_count;
        }
    }
    out
}

/// Per-thread cache updated from `long_horizon.manifest_gate_*` / `completion_audit` / `audit_unmet`.
#[derive(Debug, Clone, Default)]
pub struct CompletionGatePanelCache {
    pub active: bool,
    pub mode: Option<String>,
    pub manifest_round: u32,
    pub audit_round: u32,
    pub first_gap_count: Option<u32>,
    pub integration_gap_count: Option<u32>,
    pub gate_reinject_while_blocked: u32,
    pub last_manifest_passed: Option<bool>,
    pub last_audit_pass: Option<bool>,
    pub last_unmet_reason: Option<String>,
}

/// Live engine session snapshot when the op loop is reachable.
#[derive(Debug, Clone, Copy)]
pub struct CompletionGateSessionSnapshot {
    pub manifest_gate_rounds: u32,
    pub audit_rounds: u32,
    pub first_gap_count: Option<u32>,
    pub integration_gap_count: Option<u32>,
    pub gate_reinject_while_blocked: u32,
}

impl CompletionGatePanelCache {
    pub fn apply_status(&mut self, message: &str, payload: Option<&Value>) {
        if message.starts_with("long_horizon.manifest_gate_start:") {
            self.active = true;
            if let Some(p) = payload
                && let Some(m) = p.get("mode").and_then(Value::as_str)
            {
                self.mode = Some(m.to_string());
            }
            return;
        }
        if message.starts_with("long_horizon.manifest_gate_result:") {
            if let Some(p) = payload {
                if let Some(v) = p.get("passed").and_then(Value::as_bool) {
                    self.last_manifest_passed = Some(v);
                }
                if let Some(r) = p.get("manifest_round").and_then(Value::as_u64) {
                    self.manifest_round = r as u32;
                }
            }
            return;
        }
        if message.starts_with("long_horizon.completion_audit:") {
            if let Some(p) = payload {
                if let Some(v) = p.get("pass").and_then(Value::as_bool) {
                    self.last_audit_pass = Some(v);
                }
                if let Some(r) = p.get("manifest_round").and_then(Value::as_u64) {
                    self.manifest_round = r as u32;
                }
            }
            return;
        }
        if message.starts_with("long_horizon.audit_unmet:") {
            if let Some(p) = payload {
                if let Some(r) = p.get("reason").and_then(Value::as_str) {
                    self.last_unmet_reason = Some(r.to_string());
                }
                if let Some(r) = p.get("manifest_round").and_then(Value::as_u64) {
                    self.manifest_round = r as u32;
                }
                if let Some(r) = p.get("audit_round").and_then(Value::as_u64) {
                    self.audit_round = r as u32;
                }
                if let Some(g) = p.get("first_gap_count").and_then(Value::as_u64) {
                    self.first_gap_count = Some(g as u32);
                }
            }
            return;
        }
        if message.starts_with("long_horizon.manifest_gate:") {
            if let Some(p) = payload {
                if let Some(r) = p.get("manifest_round").and_then(Value::as_u64) {
                    self.manifest_round = r as u32;
                }
                if let Some(r) = p.get("audit_round").and_then(Value::as_u64) {
                    self.audit_round = r as u32;
                }
                if let Some(g) = p.get("first_gap_count").and_then(Value::as_u64) {
                    self.first_gap_count = Some(g as u32);
                }
                if let Some(g) = p.get("gate_reinject_while_blocked").and_then(Value::as_u64) {
                    self.gate_reinject_while_blocked = g as u32;
                }
                if let Some(m) = p.get("mode").and_then(Value::as_str) {
                    self.mode = Some(m.to_string());
                } else if p.get("enforce").and_then(Value::as_bool) == Some(true) {
                    self.mode = Some("enforce".to_string());
                } else if p.get("observe").and_then(Value::as_bool) == Some(true) {
                    self.mode = Some("observe".to_string());
                }
            }
            return;
        }
        if message.starts_with("long_horizon.integration_gate:")
            && let Some(p) = payload
        {
            if let Some(g) = p.get("gap_count").and_then(Value::as_u64) {
                self.integration_gap_count = Some(g as u32);
            }
            if p.get("enforce").and_then(Value::as_bool) == Some(true) {
                self.mode = Some("enforce".to_string());
            }
        }
    }
}