yog 0.0.76

yog: the standalone server for litany loops — the world, the balls and the conversations, behind one wire
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

//! The **policy** families' half of the parity table (§8.5): the gestures whose
//! subject is what an agent may do rather than what it is doing — the §4.11
//! hold answer and its §4.9 floor, the §4.9 monitor, and the §4.3 armed loop.
//!
//! Split from [`super`] at §12's cap, on the seam those four share: each is
//! aimed by the seat, each carries only what no seat could supply, and each
//! reads back as itself from the seat it was spelled at.

use super::super::ctx;
use super::rt;
use crate::boundary::line::{Context, parse};
use crate::boundary::{Action, Gesture, Query};
use crate::monitor::Verb;

/// The §8.6 capability answer: aimed by the seat like `/seen`, and its tail is
/// the verdict and how far it stands — the held `tool_use` id is derived at
/// fire time, so there is nothing else a line could carry.
#[test]
fn every_hold_answer_round_trips_and_a_bad_verdict_refuses() {
    use crate::control::judge::{Answer, Ruling, Scope};
    for ruling in [Ruling::Pass, Ruling::Hold, Ruling::Refuse] {
        for scope in [Scope::Call, Scope::Conversation, Scope::Workspace] {
            rt(Gesture::Act(Action::AnswerHold {
                workspace: "ws".to_owned(),
                agent: "c-1".to_owned(),
                answer: Answer { ruling, scope },
            }));
        }
    }
    let bad = parse("/answer maybe", &ctx()).expect_err("only the three words");
    assert!(bad.contains("unknown verdict"), "{bad}");
    let bare = parse("/answer", &ctx()).expect_err("no default verdict exists");
    assert!(bare.contains("pass, hold or refuse"), "{bare}");
    // The scope is a flag, and an unknown one refuses rather than defaulting:
    // a wide answer read out of a typo is the one mistake a default makes.
    let scope = parse("/answer pass --scope everywhere", &ctx()).expect_err("three scopes");
    assert!(scope.contains("unknown scope"), "{scope}");
    // …and the default is the narrow one, which is what leaving it off means.
    assert_eq!(
        parse("/answer pass", &ctx()).expect("the call alone"),
        Gesture::Act(Action::AnswerHold {
            workspace: "ws".to_owned(),
            agent: "c-1".to_owned(),
            answer: Answer::once(Ruling::Pass),
        })
    );
}

/// The §4.9 fifth rung over that same fold: two verbs, aimed by the seat, each
/// carrying nothing at all — the direction *is* the verb.
#[test]
fn the_capability_floor_round_trips_both_ways_and_takes_no_words() {
    for raised in [true, false] {
        rt(Gesture::Act(Action::Floor {
            workspace: "ws".to_owned(),
            agent: "c-1".to_owned(),
            raised,
        }));
    }
    let extra = parse("/revoke everything", &ctx()).expect_err("it takes no arguments");
    assert!(extra.contains("takes no arguments"), "{extra}");
    let unaimed = parse("/restore", &Context::default()).expect_err("nothing is selected");
    assert!(unaimed.contains("no workspace in context"), "{unaimed}");
    let unselected = parse(
        "/restore",
        &Context {
            workspace: Some("ws".to_owned()),
            ..Context::default()
        },
    )
    .expect_err("a floor is written for a conversation, and none is selected");
    assert!(
        unselected.contains("no conversation is selected"),
        "{unselected}"
    );
}

/// The alignment monitor's three (VISION §4.9): arming carries its model pin,
/// disarming names nothing, and a flag carries its reason verbatim.
#[test]
fn every_monitor_action_round_trips() {
    rt(Gesture::Act(Action::Monitor(Verb::Arm {
        workspace: "ws".to_owned(),
        model: "claude-haiku-4-5".to_owned(),
    })));
    rt(Gesture::Act(Action::Monitor(Verb::Disarm {
        workspace: "ws".to_owned(),
    })));
    rt(Gesture::Act(Action::Monitor(Verb::Flag {
        workspace: "ws".to_owned(),
        agent: "c-1".to_owned(),
        reason: "it is rewriting an unrelated crate".to_owned(),
    })));
    rt(Gesture::Ask(Query::Workspaces));
}

/// The armed loop's two (VISION §4.3): arming carries its cap, disbanding names
/// nothing at all. The project and the workspace are the seat's, so the line
/// elides them and the context supplies them back.
#[test]
fn every_fleet_action_round_trips() {
    rt(Gesture::Act(Action::Fleet(crate::fleet::Verb::Arm {
        workspace: "ws".to_owned(),
        project: "proj".to_owned(),
        cap: 4,
    })));
    rt(Gesture::Act(Action::Fleet(crate::fleet::Verb::Disarm {
        workspace: "ws".to_owned(),
    })));
    rt(Gesture::Ask(Query::Conversations {
        workspace: "ws".to_owned(),
    }));
    rt(Gesture::Ask(Query::Balls));
    rt(Gesture::Ask(Query::Board));
    rt(Gesture::Ask(Query::Attention));
    rt(Gesture::Ask(Query::Ops { max: 12 }));
    // Both moods of the needle: text, and the empty one that clears.
    for text in ["", "tekeli-li"] {
        rt(Gesture::Ask(Query::Search {
            text: text.to_owned(),
        }));
    }
    // Both moods of the work-diff: the listing, and one file's patch.
    for file in [
        None,
        Some(crate::workdiff::WorkFile {
            ball: "bl-1".to_owned(),
            handle: None,
            path: "src/a.rs".to_owned(),
        }),
        // The three-word form: a fan candidate's file (bl-c2bd).
        Some(crate::workdiff::WorkFile {
            ball: "bl-1".to_owned(),
            handle: Some("at-1a2b3c4d".to_owned()),
            path: "src/a.rs".to_owned(),
        }),
    ] {
        rt(Gesture::Ask(Query::WorkDiff {
            workspace: "ws".to_owned(),
            file,
        }));
    }
    // The §3.9 projection: the address is the seat's and it takes nothing else.
    rt(Gesture::Ask(Query::Science {
        workspace: "ws".to_owned(),
    }));
    rt(Gesture::Ask(Query::Help { verb: None }));
    rt(Gesture::Ask(Query::Help {
        verb: Some("prepare".to_owned()),
    }));
}

/// The §3.5 spend family (bl-53d1): every word stated, nothing elided, so
/// each act round-trips from a seat holding nothing at all — and the figures
/// come back to the micro, `off` spelling both deletes.
#[test]
fn every_spend_gesture_round_trips_from_an_empty_seat() {
    use crate::spend::Price;
    let bare = Context::default();
    let gestures = [
        Gesture::Act(Action::Price {
            provider: "anthropic".to_owned(),
            model: "opus".to_owned(),
            rates: Some(Price {
                input: 15_000_000,
                output: 75_000_000,
                cache_read: 1_500_000,
                cache_write: 18_750_000,
            }),
        }),
        Gesture::Act(Action::Price {
            provider: "claude-session-direct".to_owned(),
            model: crate::spend::ANY.to_owned(),
            rates: Some(Price::default()),
        }),
        Gesture::Act(Action::Price {
            provider: "anthropic".to_owned(),
            model: "opus".to_owned(),
            rates: None,
        }),
        Gesture::Act(Action::Ceiling {
            micro_usd: Some(12_500_000),
        }),
        Gesture::Act(Action::Ceiling { micro_usd: None }),
        Gesture::Ask(Query::Prices),
    ];
    for gesture in gestures {
        rt(gesture.clone());
        let line = crate::boundary::line::spell(&gesture);
        assert_eq!(parse(&line, &bare), Ok(gesture), "via {line} at no seat");
    }
    // Two rates price a row, the other two being the table's own zeros; three
    // is the cache-read alone.
    assert_eq!(
        parse("/price anthropic opus 15 75", &bare),
        Ok(Gesture::Act(Action::Price {
            provider: "anthropic".to_owned(),
            model: "opus".to_owned(),
            rates: Some(Price {
                input: 15_000_000,
                output: 75_000_000,
                cache_read: 0,
                cache_write: 0,
            }),
        }))
    );
    assert_eq!(
        parse("/price anthropic opus 15 75 1.5", &bare),
        Ok(Gesture::Act(Action::Price {
            provider: "anthropic".to_owned(),
            model: "opus".to_owned(),
            rates: Some(Price {
                input: 15_000_000,
                output: 75_000_000,
                cache_read: 1_500_000,
                cache_write: 0,
            }),
        }))
    );
}