yog 0.0.4

yog: a balls-oriented session manager for lernie loops (egui frontend)
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

//! The §9.4 picker's RAM (§5.3) — the surface's whole cross-frame state, held
//! only while the picker that asked is open, plus the write seams folded once
//! from the env snapshot. Inert: nothing here paints, and every field is
//! `pub(super)`, i.e. reachable exactly where it was when it lived in
//! [`super`] — the pane, [`super::marks`] and [`super::write`].

use crate::config_edit::RealFileIo;
use crate::config_edit::brazen::{ProviderRow, RealBzRunner};
use crate::config_edit::lernie_global::LernieGlobal;
use crate::model_pick::ModelRow;
use crate::model_pick::query::Roster;
use crate::xdg::Env;

/// The conversation's model row, held with the exact facts it was derived
/// from: the agent's branch tip, the workspace's config-lineage tip, and the
/// role the row reports. Keying on all three is exact rather than a staleness
/// gamble — a fork point is immutable, the §9.4 drift clause moves only when the
/// lineage tip does (precisely the change the operator made and did not see,
/// bl-9786), and the role moves only when the pane's strip re-scopes the two
/// dropdowns (bl-cd2a).
pub(super) struct FrozenMemo {
    pub(super) key: (String, String, String),
    /// The governing commit's short oid — what the pane scopes its write claim
    /// with, so the memo answers both questions from one derivation.
    pub(super) short_oid: String,
    pub(super) row: ModelRow,
}

/// The §11 birth-config block's row, held with the config-branch head it was
/// read at and the role it reports. No fork point: a conversation that does not
/// exist yet has not parted from anything, so there is nothing here for a drift
/// clause to be about (bl-824e).
pub(super) struct BirthMemo {
    pub(super) key: (String, String),
    pub(super) row: ModelRow,
}

/// The picker's RAM (§5.3): whether it is open, which role is selected, the
/// in-flight roster run, and the last write's outcome — plus the seams the two
/// writes go through, folded once from the env snapshot.
pub struct PickerState {
    pub open: bool,
    pub(super) role: Option<String>,
    /// The brazen provider row the operator selected, once they have moved off
    /// the default (bl-bd89). `None` means "whatever
    /// [`default_row`](crate::model_pick::default_row) says for the selected
    /// role", so a role change re-defaults rather than carrying a stale row.
    pub(super) provider: Option<String>,
    /// The model id chosen from the roster dropdown, and — when the *custom
    /// model id…* entry is chosen instead — the id being typed. `custom` being
    /// `Some` is what makes the free-entry field visible, so an empty string
    /// there is a live choice rather than "nothing chosen".
    pub(super) model: Option<String>,
    pub(super) custom: Option<String>,
    pub(super) roster: Option<Roster>,
    /// The last write's sentence and the ticket its receipt lands under
    /// (REMOTE §9.8, bl-4841) — the pick and the drift exit share it, because
    /// they are one line: whichever the operator spent, this is what it means.
    pub(super) act: crate::shell::act::Held,
    /// The model line memoized on the two oids it is derived from (§5.3
    /// memoized derived snapshots). Without it the header would re-run
    /// `governing_config` (several git spawns) on every repaint.
    pub(super) frozen: Option<FrozenMemo>,
    /// The birth line memoized on the config-branch head it was read at — the
    /// same several-git-spawns problem, one key instead of two.
    pub(super) birth: Option<BirthMemo>,
    /// The config-branch tip's `providers.yaml`, read once per open rather than
    /// per frame; cleared by [`toggle`](Self::toggle) and after a write.
    pub(super) tip_providers: Option<String>,
    /// brazen's effective provider rows and the global `models.yaml` text — the
    /// two halves of "is the role's current model live?", each asked once per
    /// open on the same terms as `tip_providers`. The rows are held **whole**,
    /// `auth` column included: the credential fault's remedy is derived from
    /// that column (bl-91f1), so reducing them to names here would throw away
    /// the fact one paint later and buy a second read of it.
    pub(super) rows: Option<Vec<ProviderRow>>,
    pub(super) models_text: Option<String>,
    pub(super) io: RealFileIo,
    pub(super) bz_runner: RealBzRunner,
    /// The wall layer (§16.2 as amended) the `--list-models` spawn is fired
    /// with, so the roster is listed against this workspace's providers and
    /// cached in this workspace's own cache.
    pub(super) wall: Vec<(String, String)>,
    pub(super) lernie: LernieGlobal,
}

impl PickerState {
    /// Fold the write seams from `wall` — the lensed env of the workspace this
    /// picker belongs to (§16.2 as amended); the surface starts closed.
    ///
    /// There is no re-seating verb: a picker is one wall's for life, and a focus
    /// change swaps the whole state (bl-5894). Re-seating two seams in place
    /// left the open flag, the role, the half-made pick and the roster from the
    /// previous sphere on screen and actionable against this one.
    pub fn new(wall: &Env) -> Self {
        Self {
            open: false,
            role: None,
            provider: None,
            model: None,
            custom: None,
            roster: None,
            act: crate::shell::act::Held::default(),
            frozen: None,
            birth: None,
            tip_providers: None,
            rows: None,
            models_text: None,
            io: RealFileIo,
            bz_runner: RealBzRunner::resolve(wall),
            wall: crate::world::wall::pairs_of(wall),
            lernie: LernieGlobal::resolve(wall),
        }
    }

    /// The `m` binding and the model line's *change…* button (§11): opening always
    /// discards the previous answer, so the next paint re-fires the query.
    pub fn toggle(&mut self) {
        self.open = !self.open;
        self.role = None;
        self.forget_choice();
        self.roster = None;
        self.tip_providers = None;
        self.rows = None;
        self.models_text = None;
        self.act.forget();
    }

    /// Drop the provider row and model chosen for the previous role, so the
    /// next one defaults off its own assignment instead of inheriting a pick
    /// that was never about it.
    pub(super) fn forget_choice(&mut self) {
        self.provider = None;
        self.model = None;
        self.custom = None;
    }
}