yog 0.0.2

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
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

//! The selected-conversation center panel (§11 altitude 1). Coverage-excluded
//! glue: the auth-failed detection and every
//! inspector view-model are tested (`AppModel`, `nav::convs`, `login::auth`,
//! `inspector`); this file only wires widgets. The composer docks at the
//! bottom of this pane and the activity accessory at the window's
//! ([`super::input_bar`], [`super::activity`], bl-c038) —
//! yog's own plumbing never renders inline between conversation content.
//!
//! **The header is the identity line and nothing else** (bl-2e18: every
//! setting for a conversation moves to the bottom instead of the top). The
//! name, the when-seat, the live-activity
//! badge and the live mark ride it; every config-shaped row — the §9.4 model
//! line, the §3.5 spend figures — moved to the bottom stack beside the
//! composer ([`super::settings`]), which is also where the birth-config block
//! now answers the same question with an empty selection ([`super::birth`]).
//! **The centre renders no membership list** (bl-8905). It used to carry a
//! compact descent tree — one selectable row per member — which bl-fa82 turned
//! into a second rendering of the conversation list's own unfolded rows, on the
//! same screen, driving the same selection. The centre's membership reading is
//! now the header's live mark alone: one circle per agent, hue = what each is
//! doing, the roster on hover. Selecting a member is the list's gesture.

use crate::AppModel;
use crate::cli_outbound::Cli;
use crate::git_tree::Agent;
use crate::nav::convs::root_of;
use crate::theme;
use std::path::{Path, PathBuf};

use super::ShellState;

/// Render the center: the selected conversation — the identity header (the §3.3
/// display name, when it started, the live badge and mark — the mark being the
/// centre's one membership reading, one circle per agent, since bl-8905 retired
/// the descent tree that repeated the list),
/// the inline Login banner on an auth-failed latest step, and the Altitude-2
/// inspector (Transcript first). The conversation's config-shaped rows are not
/// here: they are the bottom stack's ([`super::settings`], bl-2e18).
pub fn center(
    ui: &mut egui::Ui,
    model: &mut AppModel,
    state: &mut ShellState,
    lernie: &Cli,
    bl: &Cli,
    bz: &Cli,
) {
    let Some(ws) = model.focused_workspace().map(PathBuf::from) else {
        super::bootstrap::render(ui, model, state, lernie, bl);
        return;
    };
    // "Replay is not a mode": the same view renders it, only the mutating
    // composer is withheld — a replay is read-only (§3.1).
    if model.focused_is_replay() {
        ui.weak("replay · read-only");
    }
    let Some(agent) = model.focused_agent().cloned() else {
        // Nothing selected is not an empty seat — but what fills it is the
        // birth-config block down in the settings rows (bl-824e, re-seated by
        // bl-2e18), where every config-shaped row now lives.
        ui.weak("select a conversation — or start one below");
        return;
    };
    let agent_id = agent.agent_id.clone();
    let agent_state = agent.state;
    let agent_marks = agent.marks();
    let agents: Vec<Agent> = model
        .focused_tree()
        .map(|t| t.agents.clone())
        .unwrap_or_default();
    let root = root_of(&agents, &agent_id).unwrap_or_else(|| agent_id.clone());
    header(ui, model, &ws, &agents, &root);
    // The §6 marks the *focused* agent wears, said outright — this seat has the
    // room, and it is the one surface a jump-to-attention always lands on. It is
    // what answers "why was I sent here" after arriving acknowledged the signal:
    // the flag is gone, the fact is not (§6, §11 badge-seat pattern).
    for mark in agent_marks {
        let (_, hue, phrase) = theme::mark_badge(mark);
        ui.colored_label(hue, phrase);
    }
    // The focused agent's steps view, once per snapshot (§7.2 `SnapMemo`,
    // bl-e90a): the auth and wound banners below read it every frame, and
    // re-building it from disk per frame — twice — was the chat pane's
    // sluggish-scroll cost (every step's whole `response.json` re-read and
    // re-parsed on each paint).
    let steps = state.inspector.steps_memo.read(
        model.derivation(),
        (ws.clone(), agent_id.clone(), agent_state),
        &mut || crate::steps_view::build(&ws, &agent_id, agent_state),
    );
    let auth_failed = crate::login::auth::latest_step_auth_failed(steps);
    let wound = crate::steps_view::latest_wound(steps);
    // A conversation whose latest step is an auth-shaped failure banners Login
    // inline (§11/§8.3) — the Z8 machinery, one click away where the wound is.
    //
    // The banner names the row when one is derivable (bl-8e34), because "log in
    // below" against brazen's whole table is a question, not a remedy: the pane
    // offers every row and the operator has to know which one the step was
    // dispatched on. With the row named there is nothing left to pick — but the
    // pane still opens beneath, since a *wrong* derivation must never be the
    // only way out.
    if auth_failed.offered() {
        ui.colored_label(theme::ICHOR, auth_failed.banner());
        let state_root = model.state_root().to_path_buf();
        super::login_pane::login_section(ui, &mut state.wall.login, bz, &state_root);
    }
    // A conversation whose driver died before the model said anything banners
    // the §7.3 wound here rather than leaving a `0 attempts · 0 tok` step to
    // read as quiet (bl-7f2e). Since bl-55d8 it carries **the reason in
    // words** — the tail of that step's own `stderr.log`, which is the model
    // adapter's last words (lernie ARCH §2.3) — rather than pointing at the
    // activity trail, which for a turn continued by `lernie message` holds
    // nothing at all: that driver is launched by lernie, so there is no §8.1
    // per-spawn sink for the ops row to fold. The whole sentence is composed
    // in `steps_view::wound` so the words have one home (§11 badge-seat).
    //
    // Through the grace gate (bl-90bf): both halves of the predicate now ride
    // the snapshot (the steps view above is memoized per snapshot, bl-e90a),
    // so a healthy send still reads wounded until the §7.2 poll sees the
    // driver's lock. A wound that heals inside the cadence's grace window
    // never reaches the screen; one that outlives it banners.
    if state.wound_grace.paints(
        &ws,
        &agent_id,
        wound.wounded(),
        model.cadence().wound_grace(),
    ) {
        ui.colored_label(theme::ICHOR, wound.banner());
    }
    ui.separator();
    super::inspector::tabs_and_content(ui, model, state, &ws, lernie, bl);
}

/// The conversation header (§11): the identity line — the display name, when it
/// started, the live-activity badge and the live mark — then the conversation's
/// own start-flow ball (§3.3, title/status/badge, coloured by the §3.5 join) and
/// the workspace-level bound balls (§3.2 claimant join — balls the agents picked
/// up, attributed to the workspace, not any one conversation).
///
/// **A binding is not a setting.** Which ball a conversation carries is who it
/// is, so it stays on the identity side of the settings-seat ruling; what those
/// balls have *spent* is a figure, and figures went to the bottom with the rest
/// of the config-shaped rows ([`super::settings`], bl-2e18).
fn header(ui: &mut egui::Ui, model: &AppModel, ws: &Path, agents: &[Agent], root: &str) {
    // §11 altitude 1: the id is the identifier, the name is the title — one
    // ladder (§3.3), the same one the §11 row and the §3.6 dialog read. The
    // live-activity indicator sits on that same line: the open conversation's
    // name is where the eye already rests, so the pane says what the list row
    // says, in the same seat, off the same derivation (§5.1 #28).
    let flight = crate::nav::convs::conversation_flight(agents, root);
    ui.horizontal(|ui| {
        let heading = ui.heading(crate::nav::convs::display_name_of(agents, root));
        if agents
            .iter()
            .any(|a| a.agent_id == root && a.name_display_only())
        {
            // The headline is the legacy §3.3 rung — prose no lernie name
            // fact backs — so the pane says here what the list row hovers:
            // this name is not a message target (bl-8068).
            heading.on_hover_text(theme::NAME_DISPLAY_ONLY);
        }
        // The id's stamp, read out for a human (bl-16da): the headline seat is
        // "when did this start", and the raw id — the branch name and on-disk
        // key — hovers behind it. Derived at render; the id is the storage.
        let started = crate::nav::convs::started_at(root);
        ui.weak(started.label).on_hover_text(started.hover);
        // Unlike the width-bound list row, this seat has the room — so per the
        // §11 badge-seat pattern it states the class outright rather than
        // hovering it. Only a conversation actually working asks for a repaint.
        if let Some(class) = flight {
            let (glyph, hue, says) = theme::flight_badge(class);
            let time = ui.ctx().input(|i| i.time);
            ui.colored_label(theme::pulse(hue, time), format!("{glyph} {says}"));
            ui.ctx().request_repaint_after(theme::PULSE_REPAINT_DELAY);
        }
        // The live mark, on the row it is a fact about (bl-d44e): one circle per
        // agent in this conversation's subtree, hue = what it is doing (§5.1
        // #28b). Right-aligned, so it holds the pane's own corner rather than
        // the window's — a conversation-scoped fact never belonged in the
        // altitude-0 chrome, which is about workspaces and totals. The badge
        // beside it says the subtree's ONE class in words; the mark says every
        // agent's own state at a glance. Different questions, one row.
        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
            theme::live_mark(ui, &model.mark_seats());
        });
    });
    // The per-conversation ball (source 1: the goal stamp), its title and status.
    if let Some(ball) = model.conversation_ball(root) {
        super::conv_ball::header_ball(ui, &ball);
    }
    // Workspace-level balls (§3.2): the claimant join, all the balls this
    // workspace's agents bound — the "one or more" per workspace, distinct from
    // the single per-conversation goal stamp above.
    let ws_balls = model.ws_balls(ws);
    if !ws_balls.is_empty() {
        ui.horizontal(|ui| {
            ui.weak("workspace balls:");
            for ball in &ws_balls {
                match &ball.badge {
                    Some(b) => ui.weak(format!("{} · {b}", ball.id)),
                    None => ui.weak(&ball.id),
                };
            }
        });
    }
}