rho-coding-agent 1.28.1

A lightweight agent harness inspired by Pi
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

use std::time::Instant;

use super::*;
use crate::tui::ReasoningChrome;

fn live_line_text(app: &App) -> Vec<String> {
    app.history_live_lines(80, Instant::now())
        .into_iter()
        .map(|line| {
            line.spans
                .iter()
                .map(|span| span.content.as_ref())
                .collect::<String>()
        })
        .collect()
}

fn live_contains_thinking(app: &App) -> bool {
    live_line_text(app)
        .iter()
        .any(|line| line.contains("Thinking..."))
}

// Covers: exclusive reasoning chrome matrix from zen + show_reasoning_output.
// Owner: RuntimeModelView display policy.
#[test]
fn reasoning_chrome_matrix() {
    let mut runtime = test_bootstrap().runtime;

    runtime.zen_mode = false;
    runtime.show_reasoning_output = true;
    assert_eq!(runtime.reasoning_chrome(), ReasoningChrome::FullText);
    assert!(runtime.displays_reasoning_output());
    assert!(runtime.shows_work_chrome());

    runtime.show_reasoning_output = false;
    assert_eq!(
        runtime.reasoning_chrome(),
        ReasoningChrome::ThinkingPlaceholder
    );
    assert!(!runtime.displays_reasoning_output());
    assert!(runtime.shows_work_chrome());

    runtime.zen_mode = true;
    runtime.show_reasoning_output = true;
    assert_eq!(runtime.reasoning_chrome(), ReasoningChrome::Hidden);
    assert!(!runtime.displays_reasoning_output());
    assert!(!runtime.shows_work_chrome());

    runtime.show_reasoning_output = false;
    assert_eq!(runtime.reasoning_chrome(), ReasoningChrome::Hidden);
}

// Covers: Thinking... is a render-time chrome decision, not phase state.
// Owner: history_live_lines + reasoning stretch lifecycle.
#[test]
fn thinking_placeholder_renders_only_for_open_thinking_chrome() {
    let mut app = test_app();
    app.info.runtime.zen_mode = false;
    app.info.runtime.show_reasoning_output = false;
    app.turn.reasoning_phase_mut().begin_step();

    assert!(live_contains_thinking(&app));

    // Full reasoning text: stretch can stay open; Thinking... must not paint.
    app.info.runtime.show_reasoning_output = true;
    assert_eq!(
        app.info.runtime.reasoning_chrome(),
        ReasoningChrome::FullText
    );
    assert!(app.turn.reasoning_phase().is_open());
    assert!(!live_contains_thinking(&app));

    // Zen hides Thinking... even while the stretch is open.
    app.info.runtime.zen_mode = true;
    app.info.runtime.show_reasoning_output = false;
    assert_eq!(app.info.runtime.reasoning_chrome(), ReasoningChrome::Hidden);
    assert!(!live_contains_thinking(&app));

    // Leaving zen with reasoning text off restores Thinking... while open.
    app.info.runtime.zen_mode = false;
    assert_eq!(
        app.info.runtime.reasoning_chrome(),
        ReasoningChrome::ThinkingPlaceholder
    );
    assert!(live_contains_thinking(&app));

    // Finalize closes the stretch; Thinking... ends without a policy change.
    assert!(app.turn.reasoning_phase_mut().finalize().is_none());
    assert!(!app.turn.reasoning_phase().is_open());
    assert!(!live_contains_thinking(&app));
}

// Covers: reasoning deltas keep the stretch open under zen without painting Thinking...
// Owner: event path + render policy.
#[test]
fn zen_reasoning_deltas_do_not_render_thinking_placeholder() {
    let mut app = test_app();
    let mut terminal = ratatui::Terminal::new(ratatui::backend::TestBackend::new(80, 24)).unwrap();
    app.info.runtime.zen_mode = true;
    app.info.runtime.show_reasoning_output = true;
    app.turn.reasoning_phase_mut().begin_step();

    app.handle_agent_event(
        ViewModelEvent::ReasoningDelta("secret plan".into()),
        &mut terminal,
    )
    .unwrap();

    assert!(app.turn.reasoning_phase().is_open());
    assert_eq!(app.info.runtime.reasoning_chrome(), ReasoningChrome::Hidden);
    assert!(!live_contains_thinking(&app));
    assert!(!app.info.runtime.displays_reasoning_output());
}