evolving 0.1.9

git for decisions — an immutable, content-addressed ledger of human-authored decisions that resurfaces when a bound check goes red
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
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232

//! The two frozen golden vectors. If serde_json's canonicalization ever diverges
//! from JCS for our string-only payload, these fail — the byte-stability anchor.
use ev::canonical::compute_id;
use ev::tick::{Check, Ground, Liveness, Tick};

fn book(parent: &str, observe: &str, decision: &str, grounds: Vec<Ground>) -> Tick {
    Tick {
        id: String::new(),
        parent_id: parent.into(),
        observe: observe.into(),
        decision: decision.into(),
        grounds,
        status: "live".into(),
        held_since: "".into(),
        blame: "Wang Yu".into(),
        authority: None,
        jurisdiction: None,
        source_ref: None,
        provenance: None,
    }
}

#[test]
fn compute_id_should_return_the_frozen_golden_id_when_given_the_genesis_tick() {
    // given: the genesis tick with its frozen field values
    let t = book(
        "",
        "evaluating retrieval backend",
        "freeze the retrieval schema for v2",
        vec![
            Ground {
                claim: "team still wants a frozen schema".into(),
                supports: "chosen".into(),
                check: Some(Check::Person {
                    reference: "Q3 infra review".into(),
                }),
            },
            Ground {
                claim: "pgvector would lock our schema".into(),
                supports: "rejected:pgvector".into(),
                check: None,
            },
        ],
    );

    // when: its canonical id is computed
    let id = compute_id(&t);

    // then: it matches the frozen golden id
    assert_eq!(id, "e2b337f53a1f");
}

#[test]
fn compute_id_should_stay_frozen_when_source_ref_is_set() {
    // given: the genesis tick, but carrying a non-hashed, opaque source_ref
    let mut t = book(
        "",
        "evaluating retrieval backend",
        "freeze the retrieval schema for v2",
        vec![
            Ground {
                claim: "team still wants a frozen schema".into(),
                supports: "chosen".into(),
                check: Some(Check::Person {
                    reference: "Q3 infra review".into(),
                }),
            },
            Ground {
                claim: "pgvector would lock our schema".into(),
                supports: "rejected:pgvector".into(),
                check: None,
            },
        ],
    );
    t.source_ref = Some(serde_json::Value::String("R2289".into()));

    // when: its canonical id is computed
    let id = compute_id(&t);

    // then: it is unchanged from the genesis golden (source_ref is not in the hashed payload)
    assert_eq!(id, "e2b337f53a1f");
}

#[test]
fn compute_id_should_freeze_the_harvested_binding_id_when_counter_test_is_absent() {
    // given: a harvested test binding — full 3-key liveness present, but no counter_test
    // (the migrate path can only half-prove falsifiability), with the case1 lineage/text.
    let t = book(
        "7b21f0a4c8de",
        "multi-pod restore-safety counter — chat-room R2289→R2290",
        "restore-safety counter DB-backed; reject Redis",
        vec![
            Ground {
                claim: "Argus introduces no Redis; multi-pod coord via existing DB".into(),
                supports: "chosen".into(),
                check: Some(Check::Test {
                    reference: "pytest tests/test_redis_absent.py".into(),
                    verified_at_sha: "d308afac1b2c3d4e5f60718293a4b5c6d7e8f901".into(),
                    counter_test: None,
                    liveness: Liveness {
                        platforms: vec!["linux-ci".into()],
                        triggered_by: vec!["pyproject.toml".into()],
                        surfaces: vec!["pyproject-deps".into()],
                    },
                }),
            },
            Ground {
                claim: "team still wants 0-Redis posture".into(),
                supports: "chosen".into(),
                check: Some(Check::Person {
                    reference: "Q3 infra review".into(),
                }),
            },
            Ground {
                claim: "Redis would add a new infra dependency".into(),
                supports: "rejected:Redis".into(),
                check: None,
            },
        ],
    );

    // when: its canonical id is computed
    let id = compute_id(&t);

    // then: it matches the frozen harvested golden id (counter_test key omitted from the payload)
    assert_eq!(id, "0cf784b51331");
}

#[test]
fn compute_id_should_return_the_frozen_golden_id_when_given_the_case1_tick_with_non_ascii() {
    // given: the case1 tick whose fields carry non-ascii content
    let t = book(
        "7b21f0a4c8de",
        "multi-pod restore-safety counter — chat-room R2289→R2290",
        "restore-safety counter DB-backed; reject Redis",
        vec![
            Ground {
                claim: "Argus introduces no Redis; multi-pod coord via existing DB".into(),
                supports: "chosen".into(),
                check: Some(Check::Test {
                    reference: "pytest tests/test_redis_absent.py".into(),
                    verified_at_sha: "d308afac1b2c3d4e5f60718293a4b5c6d7e8f901".into(),
                    counter_test: Some(
                        "pytest tests/test_redis_absent.py::test_redis_injection_flips_red".into(),
                    ),
                    liveness: Liveness {
                        platforms: vec!["linux-ci".into()],
                        triggered_by: vec!["pyproject.toml".into()],
                        surfaces: vec!["pyproject-deps".into()],
                    },
                }),
            },
            Ground {
                claim: "team still wants 0-Redis posture".into(),
                supports: "chosen".into(),
                check: Some(Check::Person {
                    reference: "Q3 infra review".into(),
                }),
            },
            Ground {
                claim: "Redis would add a new infra dependency".into(),
                supports: "rejected:Redis".into(),
                check: None,
            },
        ],
    );

    // when: its canonical id is computed
    let id = compute_id(&t);

    // then: it matches the frozen golden id
    assert_eq!(id, "638c47b0c9dd");
}

#[test]
fn compute_id_should_freeze_the_rejected_road_tripwire_id_when_a_rejected_ground_carries_a_check() {
    // given: the case1 lineage/text, but the rejected:Redis road now CARRIES a Check::Test — the
    // 0.1.8 tripwire byte layout (a rejected: ground WITH a check, which no other golden exercises)
    let mut t = book(
        "7b21f0a4c8de",
        "multi-pod restore-safety counter — chat-room R2289→R2290",
        "restore-safety counter DB-backed; reject Redis",
        vec![
            Ground {
                claim: "Argus introduces no Redis; multi-pod coord via existing DB".into(),
                supports: "chosen".into(),
                check: Some(Check::Test {
                    reference: "pytest tests/test_redis_absent.py".into(),
                    verified_at_sha: "d308afac1b2c3d4e5f60718293a4b5c6d7e8f901".into(),
                    counter_test: Some(
                        "pytest tests/test_redis_absent.py::test_redis_injection_flips_red".into(),
                    ),
                    liveness: Liveness {
                        platforms: vec!["linux-ci".into()],
                        triggered_by: vec!["pyproject.toml".into()],
                        surfaces: vec!["pyproject-deps".into()],
                    },
                }),
            },
            Ground {
                claim: "team still wants 0-Redis posture".into(),
                supports: "chosen".into(),
                check: Some(Check::Person {
                    reference: "Q3 infra review".into(),
                }),
            },
            Ground {
                claim: "Redis would add a new infra dependency".into(),
                supports: "rejected:Redis".into(),
                check: Some(Check::Test {
                    reference: "! grep -q redis pyproject.toml".into(),
                    verified_at_sha: "d308afac1b2c3d4e5f60718293a4b5c6d7e8f901".into(),
                    counter_test: Some("grep -q redis pyproject.toml".into()),
                    liveness: Liveness {
                        platforms: vec!["linux-ci".into()],
                        triggered_by: vec!["pyproject.toml".into()],
                        surfaces: vec!["pyproject-deps".into()],
                    },
                }),
            },
        ],
    );
    // authority is non-hashed (it must NOT move the id); set it for fidelity to a real tripwire tick
    t.authority = Some("user-ruled".into());

    // when: its canonical id is computed
    let id = compute_id(&t);

    // then: it matches the frozen tripwire golden id (a check on a rejected: ground hashes
    // identically to one on a chosen ground; authority/provenance never enter the payload)
    assert_eq!(id, "9c5feb4582ac");
}